പ്രായോഗികമായി ഒരു .നെറ്റ് മൈക്രോ സർവീസ് എൻവയോൺമെന്റിൽ ലോഗിൻ ചെയ്യുന്നു

ലോഗിംഗ് വളരെ പ്രധാനപ്പെട്ട ഒരു ഡവലപ്പർ ഉപകരണമാണ്, എന്നാൽ വിതരണം ചെയ്ത സിസ്റ്റങ്ങൾ സൃഷ്ടിക്കുമ്പോൾ, അത് നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ അടിത്തറയിൽ തന്നെ സ്ഥാപിക്കേണ്ട ഒരു കല്ലായി മാറുന്നു, അല്ലാത്തപക്ഷം മൈക്രോസർവീസുകൾ വികസിപ്പിക്കുന്നതിന്റെ സങ്കീർണ്ണത പെട്ടെന്ന് ബാധിക്കും.

.നെറ്റ് കോർ 3 ഒരു മികച്ച ചേർത്തു HTTP തലക്കെട്ടുകളിൽ പരസ്പരബന്ധം സംപ്രേഷണം ചെയ്യാനുള്ള കഴിവ്, അതിനാൽ നിങ്ങളുടെ ആപ്ലിക്കേഷനുകൾ ഇന്റർ-സർവീസ് കമ്മ്യൂണിക്കേഷനായി നേരിട്ടുള്ള HTTP കോളുകൾ ഉപയോഗിക്കുകയാണെങ്കിൽ, നിങ്ങൾക്ക് ഈ ഔട്ട്-ഓഫ്-ദി-ബോക്സ് പ്രവർത്തനം പ്രയോജനപ്പെടുത്താം. എന്നിരുന്നാലും, നിങ്ങളുടെ ബാക്കെൻഡ് ആർക്കിടെക്ചറിൽ ഒരു സന്ദേശ ബ്രോക്കർ (റാബിറ്റ്എംക്യു, കാഫ്ക മുതലായവ) വഴിയുള്ള ഇടപെടൽ ഉൾപ്പെടുന്നുവെങ്കിൽ, ഈ സന്ദേശങ്ങളിലൂടെ പരസ്പര ബന്ധത്തിന്റെ പശ്ചാത്തലം കൈമാറുന്നതിനെക്കുറിച്ച് നിങ്ങൾ ഇപ്പോഴും വിഷമിക്കേണ്ടതുണ്ട്.

ഈ ലേഖനത്തിൽ ഞങ്ങൾ ഒരു ലളിതമായ വെബ്-എപിഐ ആപ്ലിക്കേഷൻ എടുക്കുകയും ലോഗിംഗ് സംഘടിപ്പിക്കുകയും ചെയ്യും

• സ്വതന്ത്ര സേവനങ്ങളുടെ ലോഗുകൾ തമ്മിൽ എൻഡ്-ടു-എൻഡ് കോറിലേഷൻ നിലനിർത്തുക, അതുവഴി നിങ്ങൾക്ക് ക്ലയന്റിൽ നിന്നുള്ള ഒരു നിർദ്ദിഷ്ട അഭ്യർത്ഥന മൂലമുണ്ടായ എല്ലാ പ്രവർത്തനങ്ങളും എളുപ്പത്തിൽ കാണാൻ കഴിയും

• സൗകര്യപ്രദമായ വിശകലനത്തോടുകൂടിയ ഒരൊറ്റ എൻട്രി പോയിന്റ് ഉണ്ടായിരിക്കുക, അതുവഴി പിന്തുണയ്‌ക്ക് പോലും ലോഗിംഗ് ടൂൾ ഉപയോഗിക്കാനാകും, "അത്തരത്തിലുള്ള ഒരു അഭ്യർത്ഥന ഐഡിയുള്ള അപ്ലിക്കേഷനിൽ എനിക്ക് ഒരു പിശക് ലഭിച്ചു" പോലുള്ള ചോദ്യങ്ങൾ ഉപയോഗിക്കാനാകും.

ആദ്യം, ഞങ്ങളുടെ ആപ്ലിക്കേഷനായി ഒരു ലോഗിംഗ് ദാതാവിനെ തീരുമാനിക്കേണ്ടതുണ്ട്. ആധുനിക ലോഗിംഗിനുള്ള പ്രധാന ആവശ്യകത ഘടനയാണ്, അതായത്. നമ്മൾ പ്രവർത്തിക്കേണ്ടത് ഫ്ലാറ്റ് ടെക്സ്റ്റ് സന്ദേശങ്ങൾ കൊണ്ടല്ല, മറിച്ച് ഒബ്‌ജക്‌റ്റുകൾ ഉപയോഗിച്ചാണ്. അത്തരം ലോഗുകൾക്ക് നന്ദി, വ്യത്യസ്ത വീക്ഷണകോണുകളിൽ നിന്ന് ഞങ്ങളുടെ സന്ദേശങ്ങളുടെ കാഴ്ചകൾ എളുപ്പത്തിൽ നിർമ്മിക്കാനും വിശകലനങ്ങൾ നടത്താനും ഞങ്ങൾക്ക് കഴിയും.

ഞങ്ങളുടെ ആപ്ലിക്കേഷനായി ഞങ്ങൾ സെറിലോഗ് പാക്കേജ് ഉപയോഗിക്കും, ഘടനാപരമായ ലോഗിംഗിനും സമ്പന്നമായ ആഡ്-ഓൺ സിസ്റ്റത്തിനും മികച്ച പിന്തുണയുണ്ട്. ഇത് സജ്ജീകരിക്കുന്നതിനുള്ള അടിസ്ഥാന ഘട്ടങ്ങൾ ഞാൻ ഒഴിവാക്കും (ഈ വിഷയത്തിൽ നിങ്ങൾക്ക് ധാരാളം ലേഖനങ്ങൾ കണ്ടെത്താൻ കഴിയും)

• സെറിലോഗ് ഇതിനകം കോൺഫിഗർ ചെയ്തിട്ടുണ്ട്, നിങ്ങളുടെ ഡിപൻഡൻസി ഇഞ്ചക്ഷൻ പ്രൊവൈഡർക്കുള്ള ഡിഫോൾട്ട് ലോഗർ ആണ്

• അതിന്റെ കോൺഫിഗറേഷനിൽ സന്ദർഭ ഗുണങ്ങളുള്ള സന്ദേശങ്ങളുടെ സമ്പുഷ്ടീകരണം ഉൾപ്പെടുന്നു (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-യിലേക്കുള്ള എല്ലാ അഭ്യർത്ഥനകളിലും നിർബന്ധമായും "എക്സ്-കോറിലേഷൻ-ഐഡി" ഹെഡറിന്റെ ആവശ്യകത ഞങ്ങൾ അതിൽ സൂചിപ്പിക്കും.

ഒരു പാക്കേജ് ചേർക്കുന്നു പരസ്പരബന്ധം ഐഡി, നമുക്ക് ആവശ്യമുള്ള തലക്കെട്ടിൽ നിന്ന് മൂല്യം എടുക്കുക എന്നതാണ് ഇതിന്റെ പ്രവർത്തനം

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();
            });
        });

"പൂർത്തിയായി" എന്ന മൂല്യമുള്ള ഒരു സംതിംഗ്ഡൺമെസേജ് ഇവന്റ് അയച്ചുകൊണ്ട് ഞങ്ങളുടെ അപേക്ഷ ഒരു 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 സന്ദേശ പ്രോസസ്സിംഗ് പൈപ്പ്ലൈനിലേക്ക് പാക്കേജ് ഒരു ഫിൽട്ടർ ചേർക്കുന്നു, അത് സന്ദേശ സന്ദർഭത്തെ ഒരു ത്രെഡ്-സേഫ് സ്റ്റാക്കിലേക്ക് അടുക്കുന്നു. സെറിലോഗ് സ്റ്റാക്കിൽ നിന്ന് സന്ദർഭം വായിക്കുകയും ഈ അധിക പ്രോപ്പർട്ടികൾ ഞങ്ങളുടെ ലോഗ് ഒബ്ജക്റ്റുകളിലേക്ക് ചേർക്കുകയും ചെയ്യുന്നു.

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 എൻവലപ്പിന്റെ എല്ലാ പ്രോപ്പർട്ടികളിലേക്കും ആക്‌സസ് ഉള്ളതിനാൽ, ഞങ്ങൾക്ക് ലഭിക്കുന്ന കോറിലേഷൻ ഐഡന്റിഫയർ ഉപഭോഗ ആപ്ലിക്കേഷനിൽ ഉപയോഗിക്കാനും കോൾ ചെയിനിലൂടെ കൂടുതൽ കൈമാറാനും കഴിയും.

തൽഫലമായി, ഞങ്ങളുടെ ലോഗുകളിൽ ഒരു സേവനത്തിനുള്ളിൽ മാത്രമല്ല, മറ്റ് ആപ്ലിക്കേഷനുകളുമായി ഇടപഴകുമ്പോഴും CorrelationId അടങ്ങിയിരിക്കാൻ തുടങ്ങി.

അതിനാൽ, .Net ആപ്ലിക്കേഷനുകളിലെ തത്ഫലമായുണ്ടാകുന്ന ലോഗിംഗ് സിസ്റ്റം, ഒരു മെസേജ് ബ്രോക്കർ വഴി പ്രവർത്തിക്കുന്നവ പോലും - തികച്ചും വ്യത്യസ്തമായ മൈക്രോസർവീസുകളിൽ നിന്നുള്ള ലോഗുകൾ ഒരു പ്രശ്നവുമില്ലാതെ പരസ്പരം ബന്ധിപ്പിക്കാൻ ഞങ്ങളെ അനുവദിക്കുന്നു. ഇലാസ്റ്റിക് സെർച്ചിന്റെ സഹായത്തോടെ, കിബാനയിൽ നമുക്കാവശ്യമായ ഡാഷ്‌ബോർഡുകൾ നിർമ്മിച്ചുകൊണ്ട് ലോഗുകൾ വേഗത്തിലും സൗകര്യപ്രദമായും വിശകലനം ചെയ്യാം (ഒരു ഉദാഹരണം പോസ്റ്റിനുള്ള ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്നു).

തീർച്ചയായും, ഈ ഫോമിൽ ലോഗിൻ ചെയ്യുന്നത് നിങ്ങളുടെ സേവനങ്ങളും വിവിധ ബാഹ്യ സിസ്റ്റങ്ങളും തമ്മിലുള്ള സങ്കീർണ്ണമായ ഇടപെടലുകളെ ഉൾക്കൊള്ളില്ല, എന്നാൽ പ്രോജക്റ്റ് വികസനത്തിന്റെ തുടക്കത്തിൽ തന്നെ അത്തരം ക്രമം സ്ഥാപിക്കുന്നത് ഒന്നിലധികം തവണ നിങ്ങൾ സ്വയം നന്ദി പറയുന്ന കാര്യങ്ങളിൽ ഒന്നാണ്.

പ്രോജക്റ്റിൽ തത്ഫലമായുണ്ടാകുന്ന സിസ്റ്റത്തിന്റെ സോഴ്സ് കോഡ് നിങ്ങൾക്ക് മനസ്സിലാക്കാൻ കഴിയും: github.com/a-postx/YA.ServiceTemplate

അവലംബം: www.habr.com