यही स्थिति है।

हमारे पास एक सेवा बस द्वारा ट्रिगर किया गया एक Azure फ़ंक्शन है जो संदेशों को एकत्र करना चाहिए और उन्हें ApplicationInsights पर पोस्ट करना चाहिए।

यही वह कोड है जिसे हमने फ़ंक्शन के लिए लिखा था

public class TopicToApplicationInsightsLogs
{
    private readonly IApplicationInsightsService _appInsightsService;

    public TopicToApplicationInsightsLogs(IApplicationInsightsService appInsightsService)
    {
        _appInsightsService = appInsightsService;
    }

    [FunctionName("TopicToApplicationInsightsLogs")]
    public async Task Run(
        [ServiceBusTrigger("%MonitorLogTopic%", "%MonitorLogSubcription%", Connection = "MonitorLogServiceBusConnectionString")]
        string jsonData,
        ILogger log,
        MessageReceiver messageReceiver,
        string lockToken
    )
    {
        var jObject = JObject.Parse(jsonData);
        var data = jObject.GetValue("Data").ToObject<Common.Domain.Payloads.Entities.MonitorLog>();

        try
        {
            foreach (var edgeLog in data.Data.Logs)
            {
                _appInsightsService.TrackTrace(edgeLog);

                if (!string.IsNullOrWhiteSpace(edgeLog.SerializedException))
                {
                    _appInsightsService.TrackException(edgeLog);
                }

                _appInsightsService.Flush();
            }

            await messageReceiver.CompleteAsync(lockToken);
            log.LogInformation($"Posted {data.Data.Logs.Count()} posts.");
        }
        catch (Exception ex)
        {
            await messageReceiver.DeadLetterAsync(lockToken);
            log.LogError($"Error posting logs: {ex.Message}", ex);

            throw;
        }
    }
}

और वह है ApplicationInsightsService.cs सामग्री

public class ApplicationInsightsService : IApplicationInsightsService
{
    private readonly TelemetryClient _telemetryClient;

    public ApplicationInsightsService()
    {
        var appInsightsConnectionString = Environment.GetEnvironmentVariable("ApplicationInsightsConnectionString", EnvironmentVariableTarget.Process);
        var appInsightsInstrumentationKey = Environment.GetEnvironmentVariable("ApplicationInsightsInstrumentationKey", EnvironmentVariableTarget.Process);

        var config = TelemetryConfiguration.CreateDefault();
        config.ConnectionString = appInsightsConnectionString;
        //config.TelemetryInitializers.Add(new OperationCorrelationTelemetryInitializer());
        _telemetryClient = new TelemetryClient(config)
        {
            InstrumentationKey = appInsightsInstrumentationKey
        };
        //_telemetryClient.Context.User.Id = Assembly.GetExecutingAssembly().GetName().Name;
        //_telemetryClient.Context.Device.Id = Environment.MachineName;
    }

    public void TrackTrace(MonitorLogDataRecord log)
    {
        var traceTelemetry = log.ToTraceTelemetry();
        _telemetryClient.TrackTrace(traceTelemetry);
    }

    public void TrackException(MonitorLogDataRecord log)
    {
        var exception = log.ToExceptionTelemetry();

        _telemetryClient.TrackException(exception);
    }

    public void TrackEvent(MonitorLogDataRecord log)
    {
        var dict = new Dictionary<string, string> {{"log", JsonConvert.SerializeObject(log)}};
        _telemetryClient.TrackEvent("Test", dict);
    }

    public void Flush()
    {
        _telemetryClient.Flush();
        // Argh
        //Task.Delay(5000).Wait();
    }
}

और ApplicationInsightsParser.cs वस्तुओं को मैप करने के लिए उपयोग किया जाता है

public static class ApplicationInsightsParser
{
    public static TraceTelemetry ToTraceTelemetry(this MonitorLogDataRecord log)
    {
        return new TraceTelemetry
        {
            Timestamp = log.Timestamp,
            //Properties = {{"", ""}},
            Context =
            {
                //Component =
                //{
                //    Version = ""
                //},
                //Device =
                //{
                //    Id = "",
                //    Model = "",
                //    OemName = "",
                //    OperatingSystem = "",
                //    Type = ""
                //},
                //Cloud =
                //{
                //    RoleInstance = "",
                //    RoleName = ""
                //},
                //Flags = 0,
                //InstrumentationKey = "",
                //Location =
                //{
                //    Ip = ""
                //},
                Operation =
                {
                    Name = log.Source
                    //CorrelationVector = "",
                    //Id = "",
                    //ParentId = "",
                    //SyntheticSource = ""
                }
                //Session =
                //{
                //    Id = "",
                //    IsFirst = true
                //},
                //User =
                //{
                //    Id = "",
                //    AccountId = "",
                //    AuthenticatedUserId = "",
                //    UserAgent = ""
                //},
                //GlobalProperties = {{"", ""}}
            },
            //Extension = null,
            //Sequence = "",
            //ProactiveSamplingDecision =SamplingDecision.None,
            Message = log.Content,
            SeverityLevel = log.Level.ParseToSeverity()
        };
    }

    public static ExceptionTelemetry ToExceptionTelemetry(this MonitorLogDataRecord log)
    {
        return new ExceptionTelemetry
        {
            Timestamp = log.Timestamp,
            //Properties = {{"", ""}},
            Context =
            {
                //Component =
                //{
                //    Version = ""
                //},
                //Device =
                //{
                //    Id = "",
                //    Model = "",
                //    OemName = "",
                //    OperatingSystem = "",
                //    Type = ""
                //},
                //Cloud =
                //{
                //    RoleInstance = "",
                //    RoleName = ""
                //},
                //Flags = 0,
                //InstrumentationKey = "",
                //Location =
                //{
                //    Ip = ""
                //},
                Operation =
                {
                    Name = log.Source
                    //CorrelationVector = "",
                    //Id = "",
                    //ParentId = "",
                    //SyntheticSource = ""
                }
                //Session =
                //{
                //    Id = "",
                //    IsFirst = true
                //},
                //User =
                //{
                //    Id = "",
                //    AccountId = "",
                //    AuthenticatedUserId = "",
                //    UserAgent = ""
                //},
                //GlobalProperties =
                //{
                //    {"", ""}

                //}
            },
            //Extension = null,
            //Sequence = "",
            //ProactiveSamplingDecision = SamplingDecision.None,
            //Message = log.Content,
            SeverityLevel = log.Level.ParseToSeverity(),
            //Metrics =
            //{
            //    {"", 0}
            //},
            Exception = JsonConvert.DeserializeObject<Exception>(log.SerializedException)
            //ProblemId = ""
        };
    }

    private static SeverityLevel ParseToSeverity(this MonitorLogDataRecordLevel logLevel)
    {
        switch (logLevel)
        {
            case MonitorLogDataRecordLevel.Debug:
                return SeverityLevel.Verbose;
            case MonitorLogDataRecordLevel.Info:
                return SeverityLevel.Information;
            case MonitorLogDataRecordLevel.Warn:
                return SeverityLevel.Warning;
            case MonitorLogDataRecordLevel.Error:
                return SeverityLevel.Error;
            case MonitorLogDataRecordLevel.Fatal:
                return SeverityLevel.Critical;
            default:
                throw new ArgumentOutOfRangeException(nameof(logLevel), logLevel, null);
        }
    }
}



सेवा को Startup.cs का उपयोग करके सिंगलटन के रूप में स्थापित किया गया है, लेकिन भले ही हमें चलते समय 0 त्रुटियां मिलती हैं और हम कतार से संदेशों को संसाधित होते हुए देखते हैं, ApplicationInsighs पर सामग्री की खोज करने पर हमें कोई ट्रेस या अपवाद नहीं मिलता है।
हमने TrackTrace, TrackExeption और TrackEvent को ज़बरदस्ती करने की कोशिश की और उस परीक्षण के बाद हम केवल Events ही देख पाए। यहां छवि विवरण दर्ज करें वेब पर खोजना हमें उस कॉन्फ़िगरेशन पर ले जाता है जिसे आप देख सकते हैं, लेकिन फिर भी हमारे लिए काम नहीं कर रहा है।

किसी भी सुझाव? किसी भी सहायता के लिए अग्रिम रूप से धन्यवाद!

0
Michele Ietri 16 अप्रैल 2020, 15:22

1 उत्तर

सबसे बढ़िया उत्तर

मुझे संदेह है कि आपने host.json फ़ाइल में sampling settings या LogLevel settings कॉन्फ़िगर किया होगा।

sampling settings के लिए, आप नमूना कॉन्फ़िगर करें और एप्लिकेशन अंतर्दृष्टि

LogLevel के लिए, आप श्रेणियों और लॉग स्तरों को कॉन्फ़िगर करें

अगर ऐसा नहीं है तो कृपया मुझे बताएं।

1
Ivan Yang 24 अप्रैल 2020, 07:04