ಪ್ರಾಯೋಗಿಕವಾಗಿ .Net microservice ಪರಿಸರದಲ್ಲಿ ಲಾಗಿನ್ ಆಗುತ್ತಿದೆ

ಲಾಗಿಂಗ್ ಬಹಳ ಮುಖ್ಯವಾದ ಡೆವಲಪರ್ ಸಾಧನವಾಗಿದೆ, ಆದರೆ ವಿತರಿಸಿದ ವ್ಯವಸ್ಥೆಗಳನ್ನು ರಚಿಸುವಾಗ, ಅದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಅಡಿಪಾಯಕ್ಕೆ ಸರಿಯಾಗಿ ಹಾಕಬೇಕಾದ ಕಲ್ಲು ಆಗುತ್ತದೆ, ಇಲ್ಲದಿದ್ದರೆ ಮೈಕ್ರೋಸರ್ವಿಸ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವ ಸಂಕೀರ್ಣತೆಯು ತ್ವರಿತವಾಗಿ ಅದರ ಟೋಲ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

.ನೆಟ್ ಕೋರ್ 3 ಉತ್ತಮವಾದದ್ದನ್ನು ಸೇರಿಸಿದೆ HTTP ಹೆಡರ್‌ಗಳಲ್ಲಿ ಪರಸ್ಪರ ಸಂಬಂಧದ ಸಂದರ್ಭವನ್ನು ರವಾನಿಸುವ ಸಾಮರ್ಥ್ಯ, ಆದ್ದರಿಂದ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಅಂತರ-ಸೇವಾ ಸಂವಹನಕ್ಕಾಗಿ ನೇರ HTTP ಕರೆಗಳನ್ನು ಬಳಸಿದರೆ, ನಂತರ ನೀವು ಈ ಬಾಕ್ಸ್‌ನ ಹೊರಗಿನ ಕಾರ್ಯದ ಲಾಭವನ್ನು ಪಡೆಯಬಹುದು. ಆದಾಗ್ಯೂ, ನಿಮ್ಮ ಬ್ಯಾಕೆಂಡ್ ಆರ್ಕಿಟೆಕ್ಚರ್ ಸಂದೇಶ ಬ್ರೋಕರ್ (RabbitMQ, Kafka, ಇತ್ಯಾದಿ) ಮೂಲಕ ಪರಸ್ಪರ ಕ್ರಿಯೆಯನ್ನು ಒಳಗೊಂಡಿದ್ದರೆ, ಈ ಸಂದೇಶಗಳ ಮೂಲಕ ಪರಸ್ಪರ ಸಂಬಂಧದ ಸಂದರ್ಭವನ್ನು ರವಾನಿಸುವ ಬಗ್ಗೆ ನೀವು ಇನ್ನೂ ಚಿಂತಿಸಬೇಕಾಗಿದೆ.

ಈ ಲೇಖನದಲ್ಲಿ ನಾವು ಸರಳವಾದ ವೆಬ್-ಎಪಿಐ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ ಮತ್ತು ಲಾಗಿಂಗ್ ಅನ್ನು ಆಯೋಜಿಸುತ್ತೇವೆ

• ಸ್ವತಂತ್ರ ಸೇವೆಗಳ ಲಾಗ್‌ಗಳ ನಡುವೆ ಅಂತ್ಯದಿಂದ ಕೊನೆಯವರೆಗೆ ಪರಸ್ಪರ ಸಂಬಂಧವನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಿ ಇದರಿಂದ ಕ್ಲೈಂಟ್‌ನಿಂದ ನಿರ್ದಿಷ್ಟ ವಿನಂತಿಯಿಂದ ಉಂಟಾದ ಎಲ್ಲಾ ಚಟುವಟಿಕೆಗಳನ್ನು ನೀವು ಸುಲಭವಾಗಿ ವೀಕ್ಷಿಸಬಹುದು

• ಅನುಕೂಲಕರ ವಿಶ್ಲೇಷಣೆಯೊಂದಿಗೆ ಒಂದೇ ಪ್ರವೇಶ ಬಿಂದುವನ್ನು ಹೊಂದಿರಿ, ಆದ್ದರಿಂದ ಬೆಂಬಲವು ಸಹ ಲಾಗಿಂಗ್ ಟೂಲ್ ಅನ್ನು ಬಳಸಬಹುದು, "ನಾನು ಅಂತಹ ಮತ್ತು ಅಂತಹ ವಿನಂತಿಯ ID ಯೊಂದಿಗೆ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ದೋಷವನ್ನು ಪಡೆದುಕೊಂಡಿದ್ದೇನೆ" ಎಂಬಂತಹ ಪ್ರಶ್ನೆಗಳನ್ನು ಬಳಸಬಹುದು

ಮೊದಲಿಗೆ, ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಲಾಗಿಂಗ್ ಪ್ರೊವೈಡರ್ ಅನ್ನು ನಾವು ನಿರ್ಧರಿಸಬೇಕು. ಆಧುನಿಕ ಲಾಗಿಂಗ್ಗೆ ಮುಖ್ಯ ಅವಶ್ಯಕತೆಯು ರಚನೆಯಾಗಿದೆ, ಅಂದರೆ. ನಾವು ಫ್ಲಾಟ್ ಪಠ್ಯ ಸಂದೇಶಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಬಾರದು, ಆದರೆ ವಸ್ತುಗಳೊಂದಿಗೆ. ಅಂತಹ ಲಾಗ್‌ಗಳಿಗೆ ಧನ್ಯವಾದಗಳು, ನಾವು ವಿವಿಧ ದೃಷ್ಟಿಕೋನಗಳಿಂದ ನಮ್ಮ ಸಂದೇಶಗಳ ವೀಕ್ಷಣೆಗಳನ್ನು ಸುಲಭವಾಗಿ ನಿರ್ಮಿಸಬಹುದು ಮತ್ತು ವಿಶ್ಲೇಷಣೆಗಳನ್ನು ನಡೆಸಬಹುದು.

ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ನಾವು ಸೆರಿಲಾಗ್ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಇದು ರಚನಾತ್ಮಕ ಲಾಗಿಂಗ್ ಮತ್ತು ಶ್ರೀಮಂತ ಆಡ್-ಆನ್ ಸಿಸ್ಟಮ್‌ಗೆ ಅತ್ಯುತ್ತಮ ಬೆಂಬಲವನ್ನು ಹೊಂದಿದೆ. ನಾನು ಅದನ್ನು ಹೊಂದಿಸುವ ಮೂಲ ಹಂತಗಳನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತೇನೆ (ಈ ವಿಷಯದ ಕುರಿತು ನೀವು ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಲೇಖನಗಳನ್ನು ಕಾಣಬಹುದು) ಮತ್ತು ಊಹೆಯನ್ನು ಮಾಡುತ್ತೇನೆ

• Serilog ಈಗಾಗಲೇ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆ ಮತ್ತು ನಿಮ್ಮ ಅವಲಂಬನೆ ಇಂಜೆಕ್ಷನ್ ಪೂರೈಕೆದಾರರಿಗೆ ಡೀಫಾಲ್ಟ್ ಲಾಗರ್ ಆಗಿದೆ

• ಅದರ ಸಂರಚನೆಯು ಸಂದರ್ಭದ ಗುಣಲಕ್ಷಣಗಳೊಂದಿಗೆ ಸಂದೇಶಗಳ ಪುಷ್ಟೀಕರಣವನ್ನು ಒಳಗೊಂಡಿದೆ (Enrich.FromLogContext)

ಸೆರಿಲಾಗ್‌ನಿಂದ ಸಂದೇಶಗಳನ್ನು ಕಳುಹಿಸಲು ಯಾವ ಕೇಂದ್ರೀಕೃತ ಲಾಗ್ ಸಂಗ್ರಹ ವ್ಯವಸ್ಥೆಯನ್ನು ಆರಿಸುವುದು ಮುಂದಿನ ಹಂತವಾಗಿದೆ. ಬಹುಶಃ ಇಂದು ಅತ್ಯಂತ ಸಾಮಾನ್ಯವಾದ ಓಪನ್ ಸೋರ್ಸ್ ಆಯ್ಕೆಯೆಂದರೆ ELK ಸ್ಟಾಕ್ (Elasticsearch, Logstash ಮತ್ತು Kibana), ಆದ್ದರಿಂದ ನಾವು ಅದನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ. ಇದನ್ನು ಮಾಡಲು, ನಾವು ಕೊಡುಗೆಯನ್ನು ಬಳಸುತ್ತೇವೆ Logz.IO — ಉಚಿತ ಯೋಜನೆಗಾಗಿ ನೋಂದಾಯಿಸಿದ ನಂತರ, ನಮ್ಮ ಕೈಯಲ್ಲಿ ಲುಸೀನ್ ಸರ್ಚ್ ಇಂಜಿನ್‌ನ ಎಲ್ಲಾ ಶಕ್ತಿಯನ್ನು ನಾವು ಹೊಂದಿದ್ದೇವೆ.

ನಾವು ಮಾಡಬೇಕಾಗಿರುವುದು ನಮ್ಮ ಯೋಜನೆಗೆ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಸೇರಿಸುವುದು Serilog.Sinks.Logzio

Install-Package Serilog.Sinks.Logzio

ಮತ್ತು ನಮ್ಮ ಲಾಗರ್‌ನ ಕಾನ್ಫಿಗರೇಶನ್‌ಗೆ ಅನುಗುಣವಾದ ಉತ್ಕೃಷ್ಟತೆಯನ್ನು ಸೇರಿಸಿ, ಅದಕ್ಕೆ ಪ್ರವೇಶ ಟೋಕನ್ ಅನ್ನು ನೀಡುತ್ತದೆ

LoggerConfiguration loggerConfig = new LoggerConfiguration();
loggerConfig.WriteTo.Logzio(secrets.LogzioToken, 10, TimeSpan.FromSeconds(10), null, LogEventLevel.Debug);

ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೂಲಕ, ನಾವು ನಮ್ಮ ಸಂದೇಶಗಳನ್ನು ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಮಾತ್ರವಲ್ಲದೆ ಕಿಬಾನಾದಲ್ಲಿಯೂ ವೀಕ್ಷಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

ಇಂಟರ್ಫೇಸ್ಗಳು

ಸೇವಾ-ರೀತಿಯ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ, ಹೊರಗಿನ ಪ್ರಪಂಚದೊಂದಿಗಿನ ಅದರ ಪರಸ್ಪರ ಕ್ರಿಯೆಗಾಗಿ ನಾವು ಎರಡು ಮುಖ್ಯ ಇಂಟರ್ಫೇಸ್‌ಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸಬಹುದು, ಅವುಗಳನ್ನು ಲಂಬ ಮತ್ತು ಅಡ್ಡ ಎಂದು ಗೊತ್ತುಪಡಿಸೋಣ. ಲಂಬ ಇಂಟರ್ಫೇಸ್ ಒಂದು ವೆಬ್ API ಆಗಿದ್ದು ಅದರ ಮೂಲಕ ಕ್ಲೈಂಟ್ ಅಪ್ಲಿಕೇಶನ್‌ನಿಂದ ಕರೆಗಳು ಬರುತ್ತವೆ. ಹಾರಿಜಾಂಟಲ್ ಎನ್ನುವುದು ಇತರ ಆಂತರಿಕ ಸೇವೆಗಳೊಂದಿಗೆ ಡೇಟಾವನ್ನು ವಿನಿಮಯ ಮಾಡಿಕೊಳ್ಳಲು ಬಳಸಲಾಗುವ ಸಂದೇಶ ಬ್ರೋಕರ್ ಆಗಿದೆ.

ಈ ಪ್ರತಿಯೊಂದು ಇಂಟರ್ಫೇಸ್‌ಗಳಲ್ಲಿ ಪರಸ್ಪರ ಸಂಬಂಧವನ್ನು ಪರಿಚಯಿಸುವ ಹಂತಗಳನ್ನು ಪರಿಗಣಿಸೋಣ.

HTTP ವಿನಂತಿಗಳಲ್ಲಿ ಪರಸ್ಪರ ಸಂಬಂಧ

ಸಾಧ್ಯವಾದಷ್ಟು ಮಾಹಿತಿಯನ್ನು ಪಡೆಯಲು, ನಾವು ಚಟುವಟಿಕೆಯ ಪ್ರಾರಂಭಕ್ಕೆ ಸಾಧ್ಯವಾದಷ್ಟು ಹತ್ತಿರದಲ್ಲಿ ಪರಸ್ಪರ ಸಂಬಂಧ ಗುರುತಿಸುವಿಕೆಯನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ, ಅಂದರೆ. ಗೇಟ್ವೇನಲ್ಲಿ ಅಥವಾ ನೇರವಾಗಿ ಕ್ಲೈಂಟ್ನಲ್ಲಿ (ಮೊಬೈಲ್ ಅಥವಾ ವೆಬ್). ಇಂದಿನಿಂದ ನಾವು ಬ್ಯಾಕೆಂಡ್ ಅಪ್ಲಿಕೇಶನ್‌ನೊಂದಿಗೆ ವ್ಯವಹರಿಸುತ್ತಿದ್ದೇವೆ, ವೆಬ್ API ಗೆ ಎಲ್ಲಾ ವಿನಂತಿಗಳಲ್ಲಿ ಕಡ್ಡಾಯವಾದ “X-Correlation-ID” ಹೆಡರ್‌ನ ಅಗತ್ಯವನ್ನು ನಾವು ಸರಳವಾಗಿ ಸೂಚಿಸುತ್ತೇವೆ.

ಪ್ಯಾಕೇಜ್ ಸೇರಿಸಲಾಗುತ್ತಿದೆ ಪರಸ್ಪರ ಸಂಬಂಧ ID, ನಮಗೆ ಅಗತ್ಯವಿರುವ ಹೆಡರ್‌ನಿಂದ ಮೌಲ್ಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುವುದು ಇದರ ಕಾರ್ಯವಾಗಿದೆ

Install-Package CorrelationID

ವಿನಂತಿಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಪೈಪ್‌ಲೈನ್‌ಗೆ ಅದನ್ನು ಸೇರಿಸೋಣ

public class Startup
{
    public void Configure(IApplicationBuilder application)
    {
        application
	    .UseCorrelationId(new CorrelationIdOptions
        {
            Header = "X-Correlation-ID",
            IncludeInResponse = false,
            UpdateTraceIdentifier = false,
            UseGuidForCorrelationId = false
        });
    }
}

ಈಗ ನಾವು ಸರಳ ಕ್ರಿಯೆಯ ಫಿಲ್ಟರ್ ಅನ್ನು ರಚಿಸಲು ಅದನ್ನು ಬಳಸುತ್ತೇವೆ:

public sealed class ApiRequestFilter : ActionFilterAttribute
{
    public ApiRequestFilter(IApiRequestTracker apiRequestTracker, ICorrelationContextAccessor correlationContextAccessor)
    {
        _correlationContextAccessor = correlationContextAccessor ?? throw new ArgumentNullException(nameof(correlationContextAccessor));
    }
    
    private readonly ICorrelationContextAccessor _correlationContextAccessor;
    
    public override async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
    {
        if (!Guid.TryParse(_correlationContextAccessor.CorrelationContext.CorrelationId, out Guid correlationId))
        {
            context.Result = new BadRequestResult();
            return;
        }
    
        await next.Invoke();
    }
    
    public override async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next)
    {
        await next.Invoke();
    }
}

ಮತ್ತು ಅದನ್ನು ನಿಯಂತ್ರಕಕ್ಕೆ ಸೇರಿಸಿ

[Route("[controller]")]
[ApiController]
[ServiceFilter(typeof(ApiRequestFilter))]
public class CarsController : ControllerBase
{

}

ಪರಿಣಾಮವಾಗಿ, ನಿಯಂತ್ರಕವು ಅನುಗುಣವಾದ ಗುರುತಿಸುವಿಕೆಯೊಂದಿಗೆ ಹೆಡರ್ ಇಲ್ಲದೆ ಎಲ್ಲಾ ವಿನಂತಿಗಳಿಗೆ 400 ಕೆಟ್ಟ ವಿನಂತಿಯನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ನಾವು ಕ್ಲೈಂಟ್‌ನಿಂದ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಸ್ವೀಕರಿಸಲು ಪ್ರಾರಂಭಿಸಿದ ನಂತರ, ನಾವು ಅದನ್ನು ಲಾಗಿಂಗ್ ಸಂದರ್ಭಕ್ಕೆ ಸೇರಿಸಬೇಕು, ಇದಕ್ಕಾಗಿ ನಾವು ಚೌಕಟ್ಟಿನ ಪದರವನ್ನು ಮಾಡುತ್ತೇವೆ:

public class CorrelationIdContextLogger
{
    public CorrelationIdContextLogger(RequestDelegate next)
    {
        _next = next ?? throw new ArgumentNullException(nameof(next));
    }
    
    readonly RequestDelegate _next;
    
    public async Task InvokeAsync(HttpContext httpContext, ILogger<CorrelationIdContextLogger> logger, ICorrelationContextAccessor correlationContextAccessor)
    {
        if (Guid.TryParse(correlationContextAccessor.CorrelationContext.CorrelationId, out Guid correlationId))
        {
            using (logger.BeginScopeWith(("CorrelationId", correlationId)))
            {
                await _next(context);
            }
        }
        else
        {
            await _next(context);
        }
    }
}

ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ, ನಾವು Microsoft.Extensions.Logging.Abstractions ಪ್ಯಾಕೇಜ್‌ನಿಂದ ಪ್ರಮಾಣಿತ ILogger ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಆದ್ದರಿಂದ ನಾವು ಅದಕ್ಕೆ ಸರಳ ವಿಸ್ತರಣೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಮೌಲ್ಯವನ್ನು ಸೇರಿಸುತ್ತೇವೆ.

public static IDisposable BeginScopeWith(this ILogger logger, params (string key, object value)[] keys)
{
    return logger.BeginScope(keys.ToDictionary(x => x.key, x => x.value));
}

ವಿನಂತಿಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಪೈಪ್ಲೈನ್ಗೆ ನಾವು ಪದರವನ್ನು ಸೇರಿಸುತ್ತೇವೆ ಮತ್ತು ಬಯಸಿದ ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯುತ್ತೇವೆ.

public class Startup
{
    public void Configure(IApplicationBuilder application)
    {
        application.UseMiddleware<CorrelationIdContextLogger>();
    }
}

ಈಗ ನಮ್ಮ ವೆಬ್ API ಗೆ ವಿನಂತಿಗಳಿಂದ ರಚಿಸಲಾದ ಎಲ್ಲಾ ಚಟುವಟಿಕೆಗಳು ಪರಸ್ಪರ ಸಂಬಂಧ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಹೊಂದಿರುತ್ತವೆ, ಅದರ ಮೂಲಕ ಅವುಗಳನ್ನು ಸುಲಭವಾಗಿ ಲಿಂಕ್ ಮಾಡಬಹುದು.

ಬ್ರೋಕರ್ ಸಂದೇಶಗಳಲ್ಲಿ ಪರಸ್ಪರ ಸಂಬಂಧ

ಸಂದೇಶ ಬ್ರೋಕರ್ ಮೂಲಕ ಪರಸ್ಪರ ಸಂಬಂಧ ಗುರುತಿಸುವಿಕೆಯ ಪ್ರಸರಣ ಮತ್ತು ಸ್ವಾಗತವನ್ನು ಹೊಂದಿಸುವುದು ಮುಂದಿನ ಹಂತವಾಗಿದೆ. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು RabbitMQ ಅನ್ನು ಬಳಸುತ್ತೇವೆ ಮತ್ತು MassTransit ಫ್ರೇಮ್ವರ್ಕ್ ಅನ್ನು ಕ್ಲೈಂಟ್ ಆಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ. ಮತ್ತೊಮ್ಮೆ, MassTransit ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಆರಂಭಿಕ ಸೆಟಪ್ ಅನ್ನು ಬಿಟ್ಟುಬಿಡೋಣ ಮತ್ತು ಲಾಗಿಂಗ್ ಅನ್ನು ಹೊಂದಿಸಲು ನೇರವಾಗಿ ಹೋಗೋಣ.

ಮೊದಲಿಗೆ, ನಾವು MassTransit ನ ಲಾಗ್‌ಗಳನ್ನು ಸೇರಿಸಿಕೊಳ್ಳಬಹುದು; ಇದಕ್ಕಾಗಿ ನಾವು ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಸೇರಿಸುತ್ತೇವೆ MassTransit.SerilogIntegration

Install-Package MassTransit.SerilogIntegration

ಈಗ MassTransit ಸೆಟ್ಟಿಂಗ್‌ಗಳಿಗೆ ಲಾಗರ್ ಸೇರಿಸಿದ ನಂತರ, ನಾವು ಫ್ರೇಮ್‌ವರ್ಕ್ ಲಾಗ್‌ಗಳನ್ನು ನೋಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

services
    .AddSingleton(provider =>
        {
            return Bus.Factory.CreateUsingRabbitMq(cfg =>
            {
                cfg.UseSerilog();
            });
        });

"ಮುಗಿದಿದೆ" ಮೌಲ್ಯದೊಂದಿಗೆ SomethingDoneMessage ಈವೆಂಟ್ ಅನ್ನು ಕಳುಹಿಸುವ ಮೂಲಕ POST ವಿನಂತಿಗೆ ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಪ್ರತಿಕ್ರಿಯಿಸಲಿ. ಅಂತಹ ಸಂದೇಶದ ಒಪ್ಪಂದವನ್ನು ಈ ಕೆಳಗಿನಂತೆ ವಿವರಿಸಬಹುದು:

namespace MbMessages
{
    public interface ISomethingDoneMessageV1
    {
        string Value { get; }
    }
}

MassTransit ಸಂದೇಶಗಳು ಮೂಲಭೂತವಾಗಿ ಬ್ರೋಕರ್ ಸಂದೇಶಗಳನ್ನು ಸುತ್ತುವರಿದ ಹೊದಿಕೆಯಾಗಿದೆ. ಹೊದಿಕೆಯು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

{
  "messageId": "59020000-5dba-0015-10b8-08d77ec28593",
  "requestId": "59020000-5dba-0015-5674-08d77ec28592",
  "conversationId": "59020000-5dba-0015-bca8-08d77ec28594",
  "destinationAddress": "rabbitmq://bear.rmq.cloudamqp.com/aelzlsta/ya.servicetemplate.receiveendpoint",
  "headers": {},
  "messageType": [
    "urn:message:MbMessages:ISomethingDoneMessageV1"
  ],
  "message": {
    "value": "done"
  }
}

ಫ್ರೇಮ್‌ವರ್ಕ್‌ನ ಕಾರ್ಯಾಚರಣೆಗೆ ಅಗತ್ಯವಾದ ಸೇವಾ ಕ್ಷೇತ್ರಗಳನ್ನು ಸಂದೇಶವು ತೋರಿಸುತ್ತದೆ, ಆದರೆ ಈ ಹೊದಿಕೆಗೆ ನಮ್ಮದೇ ಆದ ಹೆಚ್ಚುವರಿ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಸೇರಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ನಾವು ಹೊಂದಿದ್ದೇವೆ. ಇದಲ್ಲದೆ, MassTransit ಕೆಲವು ಐಚ್ಛಿಕ ಕ್ಷೇತ್ರಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಅಂತರ್ನಿರ್ಮಿತ ಪರಿಕರಗಳನ್ನು ಹೊಂದಿದೆ, ಅದರಲ್ಲಿ ಅತ್ಯಂತ ಆಸಕ್ತಿದಾಯಕವೆಂದರೆ ಪರಸ್ಪರ ಸಂಬಂಧ ಗುರುತಿಸುವಿಕೆ CorrelationId.

ಸಂದೇಶ ಒಪ್ಪಂದಕ್ಕೆ CorrelatedBy ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಸೇರಿಸೋಣ:

namespace MbMessages
{
    public interface ISomethingDoneMessageV1 : CorrelatedBy<Guid>
    {
        string Value { get; }
    }
}

ನಾವು ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸೋಣ ಮತ್ತು ಸಂದೇಶವನ್ನು ರಚಿಸುವಾಗ CorrelationId ಆಸ್ತಿಗೆ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸೋಣ:

internal class SomethingDoneMessageV1 : ISomethingDoneMessageV1
{
    internal SomethingDoneMessageV1(Guid correlationId, string value)
    {
        CorrelationId = correlationId;
        Value = value;
    }
    
    public Guid CorrelationId { get; private set; }
    public string Value { get; private set; }
}

ನಾವು ನವೀಕರಿಸಿದ ಸಂದೇಶವನ್ನು ನೋಡಿದರೆ, ಪರಸ್ಪರ ಸಂಬಂಧ ಗುರುತಿಸುವಿಕೆಯು ನಮ್ಮ ಸಂದೇಶದ ಭಾಗವಾಗಿ ಮಾತ್ರವಲ್ಲದೆ ಹೊದಿಕೆಯ ಭಾಗವಾಗಿದೆ ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ - ಈ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಈಗ ಎಲ್ಲಾ MassTransit ಲಾಗ್‌ಗಳಲ್ಲಿಯೂ ಬಳಸಲಾಗುತ್ತದೆ, ಅಂದರೆ ಅದು ತುಂಬಾ ಸುಲಭವಾಗಿರುತ್ತದೆ ಸಂದೇಶ ಬ್ರೋಕರ್ ಮಟ್ಟದಲ್ಲಿ ಸಮಸ್ಯೆಗಳನ್ನು ಎದುರಿಸಲು ನಮಗೆ.

{
  "messageId": "59020000-5dba-0015-10b8-08d77ec28593",
  "requestId": "59020000-5dba-0015-5674-08d77ec28592",
  "conversationId": "59020000-5dba-0015-bca8-08d77ec28594",
  "correlationId": "c7ff562a-b639-415b-9add-c9e524a727cc",
  "destinationAddress": "rabbitmq://bear.rmq.cloudamqp.com/aelzlsta/ya.servicetemplate.receiveendpoint",
  "headers": {},
  "messageType": [
    "urn:message:MbMessages:ISomethingDoneMessageV1"
  ],
  "message": {
    "correlationId": "c7ff562a-b639-415b-9add-c9e524a727cc",
    "value": "Hello"
  }
}

ನಾವು ಮಾಡಬೇಕಾಗಿರುವುದು ಸಂದೇಶದ ಈ ಸೇವಾ ಗುಣಲಕ್ಷಣಗಳ ಲಾಗಿಂಗ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು; ಇದಕ್ಕಾಗಿ ನಾವು ಯೋಜನೆಗೆ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಸೇರಿಸುತ್ತೇವೆ Serilog.Enrichers.MassTransitMessage. ಪ್ಯಾಕೇಜ್ MassTransit ಸಂದೇಶ ಸಂಸ್ಕರಣಾ ಪೈಪ್‌ಲೈನ್‌ಗೆ ಫಿಲ್ಟರ್ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ, ಅದು ಸಂದೇಶದ ಸಂದರ್ಭವನ್ನು ಥ್ರೆಡ್-ಸುರಕ್ಷಿತ ಸ್ಟಾಕ್‌ನಲ್ಲಿ ಜೋಡಿಸುತ್ತದೆ. Serilog ಸ್ಟಾಕ್‌ನಿಂದ ಸಂದರ್ಭವನ್ನು ಓದುತ್ತದೆ ಮತ್ತು ಈ ಹೆಚ್ಚುವರಿ ಗುಣಲಕ್ಷಣಗಳನ್ನು ನಮ್ಮ ಲಾಗ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ಸೇರಿಸುತ್ತದೆ.

Install-Package Serilog.Enrichers.MassTransitMessage

MassTransit ನಲ್ಲಿ ನಾವು ಫಿಲ್ಟರ್ ಅನ್ನು ಸೇರಿಸುತ್ತೇವೆ

services
    .AddSingleton(provider =>
        {
            return Bus.Factory.CreateUsingRabbitMq(cfg =>
            {
                cfg.UseSerilog();
                cfg.UseSerilogMessagePropertiesEnricher();
            });
        });

ಮತ್ತು ಸೆರಿಲಾಗ್ ಕಾನ್ಫಿಗರೇಶನ್‌ನಲ್ಲಿ ನಾವು ಉತ್ಕೃಷ್ಟತೆಯನ್ನು ಸೇರಿಸುತ್ತೇವೆ

Log.Logger = new LoggerConfiguration()
    .Enrich.FromMassTransitMessage()
    .CreateLogger();

RabbitMQ ಸರದಿಯಿಂದ ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸುವ ಅಪ್ಲಿಕೇಶನ್ MassTransit ಎನ್ವಲಪ್‌ನ ಎಲ್ಲಾ ಗುಣಲಕ್ಷಣಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುವುದರಿಂದ, ನಾವು ಸೇವಿಸುವ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಪರಿಣಾಮವಾಗಿ ಪರಸ್ಪರ ಸಂಬಂಧ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಬಳಸಬಹುದು, ಜೊತೆಗೆ ಕರೆ ಸರಪಳಿಯ ಉದ್ದಕ್ಕೂ ಅದನ್ನು ರವಾನಿಸಬಹುದು.

ಪರಿಣಾಮವಾಗಿ, ನಮ್ಮ ಲಾಗ್‌ಗಳು ಒಂದು ಸೇವೆಯೊಳಗೆ ಮಾತ್ರವಲ್ಲದೆ ಇತರ ಅಪ್ಲಿಕೇಶನ್‌ಗಳೊಂದಿಗೆ ಸಂವಹನ ಮಾಡುವಾಗ ಸಹ ಸಂಬಂಧ ಐಡಿಯನ್ನು ಒಳಗೊಂಡಿವೆ.

ಆದ್ದರಿಂದ, .Net ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿನ ಪರಿಣಾಮವಾಗಿ ಲಾಗಿಂಗ್ ಸಿಸ್ಟಮ್ ಯಾವುದೇ ತೊಂದರೆಗಳಿಲ್ಲದೆ ಸಂಪೂರ್ಣವಾಗಿ ವಿಭಿನ್ನ ಮೈಕ್ರೋಸರ್ವಿಸ್‌ಗಳಿಂದ ಲಾಗ್‌ಗಳನ್ನು ಪರಸ್ಪರ ಸಂಬಂಧಿಸಲು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ - ಸಂದೇಶ ಬ್ರೋಕರ್ ಮೂಲಕ ಕೆಲಸ ಮಾಡುವವರೂ ಸಹ. ಮತ್ತು Elasticsearch ಸಹಾಯದಿಂದ, ನಾವು ಕಿಬಾನಾದಲ್ಲಿ ನಮಗೆ ಅಗತ್ಯವಿರುವ ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವ ಮೂಲಕ ಲಾಗ್‌ಗಳನ್ನು ತ್ವರಿತವಾಗಿ ಮತ್ತು ಅನುಕೂಲಕರವಾಗಿ ವಿಶ್ಲೇಷಿಸಬಹುದು (ಪೋಸ್ಟ್‌ಗಾಗಿ ಚಿತ್ರದಲ್ಲಿ ಉದಾಹರಣೆಯನ್ನು ತೋರಿಸಲಾಗಿದೆ).

ಸಹಜವಾಗಿ, ಈ ಫಾರ್ಮ್‌ನಲ್ಲಿ ಲಾಗ್ ಮಾಡುವುದರಿಂದ ನಿಮ್ಮ ಸೇವೆಗಳು ಮತ್ತು ವಿವಿಧ ಬಾಹ್ಯ ವ್ಯವಸ್ಥೆಗಳ ನಡುವಿನ ಸಂಕೀರ್ಣ ಸಂವಹನಗಳನ್ನು ಒಳಗೊಳ್ಳುವುದಿಲ್ಲ, ಆದರೆ ಯೋಜನೆಯ ಅಭಿವೃದ್ಧಿಯ ಪ್ರಾರಂಭದಲ್ಲಿಯೇ ಅಂತಹ ಕ್ರಮವನ್ನು ಸ್ಥಾಪಿಸುವುದು ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಬಾರಿ ನೀವೇ ಧನ್ಯವಾದ ಹೇಳುವ ವಿಷಯಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ.

ಯೋಜನೆಯಲ್ಲಿ ಪರಿಣಾಮವಾಗಿ ಸಿಸ್ಟಮ್‌ನ ಮೂಲ ಕೋಡ್ ಅನ್ನು ನೀವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಹುದು: github.com/a-postx/YA.ServiceTemplate

ಮೂಲ: www.habr.com