ਇੱਕ Azure ਫੰਕਸ਼ਨ ਤੋਂ ਇੱਕ Azure Logic ਐਪ ਤੱਕ ਸਰਫੇਸ ਗਲਤੀਆਂ ਦੁਆਰਾ ਗਲਤੀ ਟਰੈਕਿੰਗ ਨੂੰ ਕਿਵੇਂ ਸੁਧਾਰਿਆ ਜਾਵੇ

ਤਰਕ ਐਪਸ ਵਿੱਚ ਸਰਫੇਸ ਮੁੱਦਿਆਂ ਲਈ ਅਜ਼ੂਰ ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ ਗਲਤੀ ਨੂੰ ਸੰਭਾਲਣਾ ਲਾਗੂ ਕਰਨਾ

C# ਬੈਕਐਂਡ ਹੱਲ ਦੇ ਨਾਲ Azure ਫੰਕਸ਼ਨ ਜੋ ਕਾਲਿੰਗ Azure Logic ਐਪ ਦੁਆਰਾ ਫੜੀਆਂ ਜਾਣ ਵਾਲੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਸੁੱਟਦਾ ਹੈ

// This code demonstrates a C# Azure Function designed to throw an error
// that can be caught by an Azure Logic App.
// The script uses structured error handling to ensure clear reporting in the Logic App.

using System;
using System.IO;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using System.Data.SqlClient;

public static class MyFunction
{
    [FunctionName("MyFunction")]
    public static async Task<IActionResult> Run(
        [HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
        ILogger log)
    {
        log.LogInformation("MyFunction triggered.");
        try
        {
            // Simulating database operation
            using (SqlConnection connection = new SqlConnection("YourConnectionStringHere"))
            {
                connection.Open();
                var command = new SqlCommand("INSERT INTO Table (Column) VALUES (Value);", connection);
                command.ExecuteNonQuery();
            }
            return new OkObjectResult("Data inserted successfully");
        }
        catch (SqlException ex)
        {
            log.LogError($"Database error: {ex.Message}");
            return new StatusCodeResult(StatusCodes.Status500InternalServerError);
        }
        catch (Exception ex)
        {
            log.LogError($"General error: {ex.Message}");
            return new StatusCodeResult(StatusCodes.Status500InternalServerError);
        }
    }
}

ਐਜ਼ੂਰ ਫੰਕਸ਼ਨ (ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਹੱਲ) ਵਿੱਚ ਗਲਤੀਆਂ ਨੂੰ ਸੰਕੇਤ ਕਰਨ ਲਈ HTTP ਸਥਿਤੀ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

Azure Logic ਐਪ ਵਿੱਚ ਫਲੈਗ ਕੀਤੀਆਂ ਜਾਣ ਵਾਲੀਆਂ ਤਰੁੱਟੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ Node.js ਬੈਕਐਂਡ ਫੰਕਸ਼ਨ

// This JavaScript function handles database operations and triggers an error response
// with an HTTP 500 status code if a failure occurs, allowing the Logic App to detect it.

const { Connection, Request } = require('tedious');

module.exports = async function (context, req) {
    context.log('JavaScript Azure Function triggered.');
    try {
        const config = {
            server: "YourServerHere",
            authentication: {
                type: "default",
                options: {
                    userName: "username",
                    password: "password"
                }
            }
        };

        const connection = new Connection(config);
        connection.on('connect', err => {
            if (err) {
                context.log.error('Database connection error', err);
                context.res = { status: 500, body: "Database connection error" };
                return;
            }

            const request = new Request("INSERT INTO Table (Column) VALUES ('Value')", err => {
                if (err) {
                    context.log.error('Database insert error', err);
                    context.res = { status: 500, body: "Database insert error" };
                } else {
                    context.res = { status: 200, body: "Data inserted successfully" };
                }
            });
            connection.execSql(request);
        });
        connection.connect();
    } catch (error) {
        context.log.error('General error', error);
        context.res = { status: 500, body: "General error occurred" };
    }
};

C# Azure ਫੰਕਸ਼ਨ ਲਈ ਯੂਨਿਟ ਟੈਸਟ

ਗਲਤੀ ਹੈਂਡਲਿੰਗ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ MSTest ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ C# Azure ਫੰਕਸ਼ਨ ਲਈ ਯੂਨਿਟ ਟੈਸਟ

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;

[TestClass]
public class MyFunctionTests
{
    [TestMethod]
    public async Task Run_ShouldReturn500_OnSqlException()
    {
        var mockLogger = new Mock<ILogger>();
        var request = new DefaultHttpContext().Request;

        // Act - Call the function
        var response = await MyFunction.Run(request, mockLogger.Object);

        // Assert
        Assert.IsInstanceOfType(response, typeof(StatusCodeResult));
        Assert.AreEqual(500, (response as StatusCodeResult)?.StatusCode);
    }
}

ਲਾਜਿਕ ਐਪਸ ਨਾਲ ਐਜ਼ੂਰ ਫੰਕਸ਼ਨ ਗਲਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ 'ਤੇ ਆਮ ਸਵਾਲ

1. ਮੈਂ ਇਹ ਕਿਵੇਂ ਯਕੀਨੀ ਬਣਾ ਸਕਦਾ ਹਾਂ ਕਿ Logic ਐਪ ਮੇਰੇ Azure ਫੰਕਸ਼ਨ ਤੋਂ ਤਰੁੱਟੀਆਂ ਨੂੰ ਫੜਦਾ ਹੈ?
2. ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਤਰਕ ਐਪ ਗਲਤੀਆਂ ਨੂੰ ਫੜਦਾ ਹੈ, ਇੱਕ HTTP ਸਥਿਤੀ ਕੋਡ ਵਾਪਸ ਕਰੋ, ਜਿਵੇਂ ਕਿ 500, ਜਦੋਂ Azure ਫੰਕਸ਼ਨ ਇੱਕ ਤਰੁੱਟੀ ਦਾ ਸਾਹਮਣਾ ਕਰਦਾ ਹੈ। ਇਹ ਤਰਕ ਐਪ ਨੂੰ ਜਵਾਬ ਨੂੰ ਅਸਫਲਤਾ ਦੇ ਰੂਪ ਵਿੱਚ ਵਿਆਖਿਆ ਕਰਨ ਦਿੰਦਾ ਹੈ।
3. ਕੀ ਮੈਂ ਗਲਤੀ ਨਾਲ ਨਜਿੱਠਣ ਲਈ ਆਪਣੇ ਤਰਕ ਐਪ ਵਿੱਚ ਮੁੜ ਕੋਸ਼ਿਸ਼ ਨੀਤੀ ਸ਼ਾਮਲ ਕਰ ਸਕਦਾ ਹਾਂ?
4. ਹਾਂ, ਤਰਕ ਐਪਾਂ ਸੰਰਚਨਾਯੋਗ ਮੁੜ-ਕੋਸ਼ਿਸ਼ ਨੀਤੀਆਂ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦੀਆਂ ਹਨ। ਤੁਸੀਂ ਆਪਣੇ Azure ਫੰਕਸ਼ਨ ਦੇ ਸੰਭਾਵਿਤ ਵਿਵਹਾਰ ਦੇ ਆਧਾਰ 'ਤੇ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਦੀਆਂ ਕੋਸ਼ਿਸ਼ਾਂ ਅਤੇ ਅੰਤਰਾਲਾਂ ਨੂੰ ਵਿਵਸਥਿਤ ਕਰ ਸਕਦੇ ਹੋ।
5. Azure ਫੰਕਸ਼ਨ ਵਿੱਚ ਸਟ੍ਰਕਚਰਡ ਲੌਗਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਕੀ ਫਾਇਦੇ ਹਨ?
6. ਸਟ੍ਰਕਚਰਡ ਲੌਗਿੰਗ, ਜਿਵੇਂ ਕਿ ILogger, ਤੁਹਾਨੂੰ ਵਿਸਤ੍ਰਿਤ ਤਰੁਟੀ ਸੁਨੇਹਿਆਂ ਨੂੰ ਕੈਪਚਰ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ, ਜੋ ਤੁਹਾਡੇ ਵਰਕਫਲੋ ਵਿੱਚ ਖਾਸ ਮੁੱਦਿਆਂ ਦੀ ਨਿਗਰਾਨੀ ਅਤੇ ਨਿਪਟਾਰਾ ਕਰਨ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ।
7. ਕੀ ਮੈਨੂੰ ਆਪਣੇ Azure ਫੰਕਸ਼ਨ ਵਿੱਚ HTTP 200 ਜਵਾਬਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ ਭਾਵੇਂ ਕੋਈ ਗਲਤੀ ਹੋਵੇ?
8. ਨਹੀਂ, ਵਰਤ ਕੇ HTTP 200 ਗਲਤੀਆਂ ਲਈ ਤਰਕ ਐਪ ਫੰਕਸ਼ਨ ਦੀ ਸਥਿਤੀ ਦੀ ਗਲਤ ਵਿਆਖਿਆ ਕਰ ਸਕਦਾ ਹੈ। ਇਸਦੀ ਬਜਾਏ, ਅਸਫਲਤਾਵਾਂ ਲਈ ਇੱਕ ਢੁਕਵਾਂ ਗਲਤੀ ਸਥਿਤੀ ਕੋਡ, ਜਿਵੇਂ 500, ਵਾਪਸ ਕਰੋ।
9. ਮੈਂ ਇੱਕ Azure ਫੰਕਸ਼ਨ ਵਿੱਚ ਕੁਨੈਕਸ਼ਨ ਸਮੱਸਿਆਵਾਂ ਦਾ ਨਿਪਟਾਰਾ ਕਿਵੇਂ ਕਰਾਂ?
10. SQL ਕਨੈਕਟੀਵਿਟੀ ਅਤੇ ਅਨੁਮਤੀਆਂ ਦੀ ਜਾਂਚ ਕਰੋ। ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ SqlConnection ਅਤੇ ਇਸ ਦੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਲੌਗ ਕਰਨ ਨਾਲ ਕਨੈਕਸ਼ਨ-ਸਬੰਧਤ ਮੁੱਦਿਆਂ ਦੀ ਪਛਾਣ ਕਰਨ ਵਿੱਚ ਮਦਦ ਮਿਲਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ ਇਜਾਜ਼ਤ ਤੋਂ ਇਨਕਾਰ ਜਾਂ ਸਰਵਰ ਦੀ ਪਹੁੰਚਯੋਗਤਾ।
11. ਕੀ ਹੁੰਦਾ ਹੈ ਜੇਕਰ ਤਰਕ ਐਪ ਗਲਤੀ ਦਾ ਸਹੀ ਪਤਾ ਨਹੀਂ ਲਗਾਉਂਦਾ?
12. ਜੇਕਰ ਕਿਸੇ ਤਰੁੱਟੀ ਦਾ ਪਤਾ ਨਹੀਂ ਲੱਗਿਆ ਹੈ, ਤਾਂ ਸਾਰੇ ਜਵਾਬਾਂ ਨੂੰ ਲੌਗ ਕਰਨ ਲਈ ਤਰਕ ਐਪ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰੋ ਜਾਂ ਮੁੱਦਿਆਂ ਦੀ ਵਧੇਰੇ ਸਟੀਕਤਾ ਨਾਲ ਪਛਾਣ ਕਰਨ ਲਈ ਸਥਿਤੀ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਇਹ ਪਹੁੰਚ ਫੰਕਸ਼ਨ ਗਲਤੀਆਂ ਲਈ ਤਰਕ ਐਪ ਦੇ ਜਵਾਬ ਨੂੰ ਵਧਾਉਂਦੀ ਹੈ।
13. ਕੀ ਮੈਂ ਗਲਤੀ ਸੰਕੇਤ ਦੇਣ ਲਈ ਇੱਕ ਕਸਟਮ HTTP ਸਥਿਤੀ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦਾ ਹਾਂ?
14. ਹਾਂ, ਜਦਕਿ 500 ਸਰਵਰ ਤਰੁਟੀਆਂ ਲਈ ਮਿਆਰੀ ਹੈ, ਜੇਕਰ ਉਹ ਤੁਹਾਡੇ ਵਰਕਫਲੋ ਦੇ ਅਨੁਕੂਲ ਹੋਣ ਤਾਂ ਤੁਸੀਂ ਦੂਜੇ ਸਟੇਟਸ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਪਰ ਗਲਤ ਵਿਆਖਿਆਵਾਂ ਤੋਂ ਬਚਣ ਲਈ ਇਕਸਾਰ ਰਹੋ।
15. JavaScript-ਅਧਾਰਿਤ Azure ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ ਮੇਰੇ ਕੋਲ ਕਿਹੜੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਦੇ ਵਿਕਲਪ ਹਨ?
16. ਵਰਤੋ context.log.error() ਲਾਗਿੰਗ ਲਈ ਅਤੇ status JavaScript-ਅਧਾਰਿਤ ਫੰਕਸ਼ਨਾਂ ਲਈ ਤਰਕ ਐਪਸ ਵਿੱਚ ਟ੍ਰਿਗਰ ਐਰਰ ਹੈਂਡਲਿੰਗ ਦੇ ਜਵਾਬਾਂ ਵਿੱਚ ਖੇਤਰ।
17. ਮੁੜ-ਕੋਸ਼ਿਸ਼ ਨੀਤੀ Azure ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ ਡੇਟਾ ਇਕਸਾਰਤਾ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਭਾਵਿਤ ਕਰਦੀ ਹੈ?
18. ਮੁੜ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਦੀਆਂ ਨੀਤੀਆਂ ਅਜ਼ੂਰ ਫੰਕਸ਼ਨ ਨੂੰ ਕਈ ਵਾਰ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦੀਆਂ ਹਨ, ਇਸ ਲਈ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਕੋਈ ਵੀ ਓਪਰੇਸ਼ਨ, ਜਿਵੇਂ ਕਿ ExecuteNonQuery(), ਤੁਹਾਡੇ ਡੇਟਾਬੇਸ ਵਿੱਚ ਡੁਪਲੀਕੇਟ ਐਂਟਰੀਆਂ ਤੋਂ ਬਚਣ ਲਈ ਅਯੋਗ ਹੈ।
19. ਫੰਕਸ਼ਨ ਵਿੱਚ ਗਲਤੀਆਂ ਹੋਣ ਦੇ ਬਾਵਜੂਦ ਵੀ ਮੇਰੀ ਲਾਜਿਕ ਐਪ ਸਫਲ ਰਨ ਕਿਉਂ ਦਿਖਾਉਂਦੀ ਹੈ?
20. ਜੇਕਰ Azure ਫੰਕਸ਼ਨ ਵਾਪਸ ਆਉਂਦਾ ਹੈ HTTP 200 ਤਰੁੱਟੀਆਂ ਦੇ ਬਾਵਜੂਦ, ਤਰਕ ਐਪ ਇਸਨੂੰ ਸਫਲਤਾ ਦੇ ਰੂਪ ਵਿੱਚ ਵਿਆਖਿਆ ਕਰਦਾ ਹੈ। ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ StatusCodeResult ਇੱਕ ਅਸਫਲਤਾ ਕੋਡ ਭੇਜਣਾ ਇਸ ਵਿਵਹਾਰ ਨੂੰ ਠੀਕ ਕਰੇਗਾ.
21. ਅਜ਼ੂਰ ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ ਅਸ਼ੁੱਧੀ ਨੂੰ ਸੰਭਾਲਣ ਵਿੱਚ ਯੂਨਿਟ ਟੈਸਟ ਕਿਵੇਂ ਮਦਦ ਕਰ ਸਕਦੇ ਹਨ?
22. ਯੂਨਿਟ ਟੈਸਟ ਤੁਹਾਨੂੰ ਗਲਤੀਆਂ ਦੀ ਨਕਲ ਕਰਕੇ ਅਤੇ ਫੰਕਸ਼ਨ ਸਹੀ ਸਥਿਤੀ ਕੋਡ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜਾਂ ਨਹੀਂ, ਇਸਦੀ ਜਾਂਚ ਕਰਕੇ ਗਲਤੀ ਸੰਭਾਲਣ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ, ਜਿਵੇਂ ਕਿ StatusCodeResult(500), ਮਜਬੂਤ ਤਰਕ ਐਪ ਏਕੀਕਰਣ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣਾ।

ਮਜਬੂਤ ਗਲਤੀ ਨਾਲ ਨਜਿੱਠਣ ਦੁਆਰਾ ਵਰਕਫਲੋ ਭਰੋਸੇਯੋਗਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣਾ

ਇੱਕ Azure ਫੰਕਸ਼ਨ ਅਤੇ ਇੱਕ ਤਰਕ ਐਪ ਦੇ ਵਿਚਕਾਰ ਪ੍ਰਭਾਵੀ ਤਰੁੱਟੀ ਨੂੰ ਸੰਭਾਲਣਾ ਬਿਹਤਰ ਦਿੱਖ ਅਤੇ ਮੁੱਦਿਆਂ ਦੇ ਤੇਜ਼ ਜਵਾਬ ਲਈ ਸਹਾਇਕ ਹੈ। ਤਰਕ ਐਪ ਨੂੰ ਗਲਤੀਆਂ ਲਈ ਸਹੀ HTTP ਸਥਿਤੀ ਕੋਡ ਵਾਪਸ ਕਰਨਾ ਸੰਕੇਤ ਦਿੰਦਾ ਹੈ ਕਿ ਇੱਕ ਗਲਤੀ ਆਈ ਹੈ, ਇਸ ਨੂੰ ਉਸ ਅਨੁਸਾਰ ਜਵਾਬ ਦੇਣ ਦੇ ਯੋਗ ਬਣਾਉਂਦਾ ਹੈ। ਸਟ੍ਰਕਚਰਡ ਲੌਗਿੰਗ ਅਤੇ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਦੀਆਂ ਨੀਤੀਆਂ ਇਸ ਭਰੋਸੇਯੋਗਤਾ ਦਾ ਹੋਰ ਸਮਰਥਨ ਕਰਦੀਆਂ ਹਨ।

Azure ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ ਵਿਸਤ੍ਰਿਤ ਲੌਗਿੰਗ ਅਤੇ ਢਾਂਚਾਗਤ ਜਵਾਬਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨਾ ਨਿਰਵਿਘਨ, ਵਧੇਰੇ ਭਰੋਸੇਮੰਦ ਵਰਕਫਲੋ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ। ਜਦੋਂ ਮੁੜ-ਕੋਸ਼ਿਸ਼ ਨੀਤੀਆਂ ਦੇ ਨਾਲ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਸੈੱਟਅੱਪ ਸਾਈਲੈਂਟ ਅਸਫਲਤਾਵਾਂ ਨੂੰ ਘੱਟ ਕਰਦਾ ਹੈ, ਡਾਟਾ ਨੂੰ ਫਲੋਇੰਗ ਅਤੇ ਸਿਸਟਮ ਨੂੰ ਚਾਲੂ ਰੱਖਦਾ ਹੈ। ਇਹਨਾਂ ਰਣਨੀਤੀਆਂ ਦੇ ਨਾਲ, ਟੀਮਾਂ ਸਮੇਂ ਦੀ ਬਚਤ ਕਰ ਸਕਦੀਆਂ ਹਨ ਅਤੇ ਵਿਸ਼ਵਾਸ ਨਾਲ ਸਿਸਟਮ ਦੀ ਸਿਹਤ ਨੂੰ ਬਣਾਈ ਰੱਖ ਸਕਦੀਆਂ ਹਨ। 🚀