استفاده از APM Elastic در .Net

using OpenTelemetry;
using OpenTelemetry.Resources;
using OpenTelemetry.Trace;
using System;
using System.Collections.Generic;
using System.Diagnostics;

namespace Utility
{
    public sealed class TraceLogger : IDisposable
    {
        private const string Source = "My";
        private readonly Activity _activity;
        private static readonly ActivitySource ActivitySource = new ActivitySource(Source);

        public TraceLogger(string actionName)
        {
            _activity = ActivitySource.StartActivity(actionName);
        }

        public void Dispose()
        {
            _activity?.Dispose();
        }

        public static void InitOpenTelemetry(string serviceName, Func<TracerProviderBuilder, TracerProviderBuilder> custom = null)
        {
            try
            {
                var attributes = new List<KeyValuePair<string, object>>
                {
                    new KeyValuePair<string, object>("deployment.environment", Source),
                    new KeyValuePair<string, object>("host.name", Environment.MachineName)
                };

                var sdk = Sdk.CreateTracerProviderBuilder()
                    .SetErrorStatusOnException()
                    .SetResourceBuilder(ResourceBuilder.CreateDefault()
                        .AddService(serviceName, serviceName)
                        .AddAttributes(attributes)
                        .AddEnvironmentVariableDetector())
                    .AddSource(Source)
                    .AddAspNetInstrumentation(a =>
                    {
                        a.RecordException = true;
                    })
                    .AddSqlClientInstrumentation(a =>
                    {
                        a.EnableConnectionLevelAttributes = true;
                        a.SetDbStatement = true;
                    })
                    .AddHttpClientInstrumentation(a =>
                    {
                        a.RecordException = true;
                        a.SetHttpFlavor = true;
                    });

                if (custom != null)
                {
                    sdk = custom(sdk);
                }

                sdk.AddOtlpExporter(options =>
                {
                    options.Endpoint = new Uri(Configs.OtlpEndpoint); //http://localhost:8200
                    options.Headers = "Authorization= ApiKey " + Configs.OtlpAuthorizationHeader; // LthOr1hva0JLTXJzeEpvqG4nUkk6WUdhLW5NdlzTNlMzbWt3SWUwNzVNQQ==
                }).Build();
            }
            catch (Exception e)
            {
                ConsoleWriter.WriteIfUserInteractive(e);
            }
        }
    }
}

  <package id="OpenTelemetry.Exporter.OpenTelemetryProtocol" version="1.2.0-rc5" targetFramework="net461" />
  <package id="OpenTelemetry.Extensions.Hosting" version="1.0.0-rc9.2" targetFramework="net461" />
  <package id="OpenTelemetry.Instrumentation.Http" version="1.0.0-rc9" targetFramework="net461" />
  <package id="OpenTelemetry.Instrumentation.SqlClient" version="1.0.0-rc9" targetFramework="net461" />
  <package id="OpenTelemetry.Exporter.Prometheus" version="1.2.0-rc5" targetFramework="net461" />
  <package id="OpenTelemetry.Instrumentation.AspNet" version="1.0.0-rc9" targetFramework="net461" />
  <package id="OpenTelemetry.Instrumentation.AspNet.TelemetryHttpModule" version="1.0.0-rc9" targetFramework="net461" />

public void Handle(NotificationMessageDto input)
{
    using (new TraceLogger(nameof(Handle)))
    {
        Activity.Current?.SetTag("isConverted", isConverted);

        // ...
    }
}

static class Program
{
    static void Main()
    {
        TraceLogger.InitOpenTelemetry("my-engine");
        // TraceLogger.InitOpenTelemetry("my-services", o => o.AddWcfInstrumentation());

        var servicesToRun = new ServiceBase[] { drsvc };
        ServiceBase.Run(servicesToRun);
    }
}

public void Critical(Exception ex)
{
    SetSeverity(nameof(Critical));
    SetException(ex);
    SerilogLogger.Fatal(ex, ex.Message);
}

private void SetSeverity(string severity)
{
    Activity.Current?.SetTag(nameof(severity), severity);
}

private void SetException(Exception exception)
{
    SetStatusCode();
    Activity.Current?.RecordException(exception);
}

private void SetStatusCode()
{
    Activity.Current?.SetStatus(ActivityStatusCode.Error, "ERROR");
}

using System;
using OpenTelemetry;
using OpenTelemetry.Metrics;
using OpenTelemetry.Resources;
using System.Diagnostics.Metrics;

namespace Utility
{
    public class Monitoring
    {
        private const string Source = "My";
        public static readonly Meter Meter = new Meter(Source);

        public static void InitOpenTelemetry(string serviceName)
        {
            try
            {
                Sdk.CreateMeterProviderBuilder()
                    .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(serviceName, serviceName))
                    .AddMeter(Source)
                    .AddHttpClientInstrumentation()
                    .AddOtlpExporter(options =>
                    {
                        options.Endpoint = new Uri(Configs.OtlpEndpoint);
                        options.Headers = "Authorization= ApiKey " + Configs.OtlpAuthorizationHeader;
                    }).Build();
            }
            catch (Exception e)
            {
                ConsoleWriter.WriteIfUserInteractive(e);
            }
        }
    }
}

private readonly Counter<long> _successMessageCounter = Monitoring.Meter.CreateCounter<long>("successMessage");
private readonly Counter<long> _failedMessageCounter = Monitoring.Meter.CreateCounter<long>("failedMessage");


public async Task Run(ChangeDto dto)
{
    using (new TraceLogger(nameof(ChangeWorker)))
    {
        try
        {
            // do work

            _successMessageCounter.Add(1);
        }
        catch (Exception ex)
        {
            _logger.Critical(ex);
            _failedMessageCounter.Add(1);
            throw;
        }
    }
}