Application Tracing in .NET for Performance Monitoring

1
using System.Diagnostics;
2
3
Trace.Listeners.Add(new TextWriterTraceListener("logfile.log"));
4
Trace.AutoFlush = true;
5
Trace.WriteLine("Starting application tracing");
6
7
// Your application logic here
8
9
Trace.WriteLine("Ending application tracing");

1
using System.Diagnostics;
2
3
var source = new DiagnosticListener("MyApplicationSource");
4
5
if (source.IsEnabled("StartRequest"))
6
{
7
    source.Write("StartRequest", new { RequestId = Guid.NewGuid(), Timestamp = DateTime.UtcNow });
8
}
9
10
// Application logic here
11
12
if (source.IsEnabled("EndRequest"))
13
{
14
    source.Write("EndRequest", new { RequestId = Guid.NewGuid(), Timestamp = DateTime.UtcNow });
15
}

1
using Microsoft.ApplicationInsights;
2
using Microsoft.ApplicationInsights.Extensibility;
3
4
var telemetryConfiguration = TelemetryConfiguration.CreateDefault();
5
telemetryConfiguration.InstrumentationKey = "your_instrumentation_key_here";
6
var telemetryClient = new TelemetryClient(telemetryConfiguration);
7
8
telemetryClient.TrackTrace("Application trace message");

1
using OpenTelemetry.Trace;
2
3
public class Startup
4
{
5
public void ConfigureServices(IServiceCollection services)
6
{
7
// Other service configurations ...
8
9
        // Configure OpenTelemetry Tracing
10
        services.AddOpenTelemetryTracing(builder =>
11
        {
12
            builder
13
                .AddAspNetCoreInstrumentation()
14
                .AddConsoleExporter(); // Using console exporter for demonstration
15
        });
16
    }
17
18
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
19
    {
20
        // Existing configuration code...
21
22
        // Ensure to use the appropriate middleware if needed
23
        app.UseOpenTelemetry();
24
    }
25
}

1
using System.Diagnostics;
2
using OpenTelemetry.Trace;
3
4
public class MyService
5
{
6
private static readonly ActivitySource ActivitySource = new ActivitySource("highlight-dot-net-example");
7
8
    public void DoWork()
9
    {
10
        using (var activity = ActivitySource.StartActivity("DoingWork"))
11
        {
12
            // Your logic here
13
            // You can add custom tags or events to 'activity' as needed
14
        }
15
    }
16
}

1
using System.Diagnostics;
2
using OpenTelemetry;
3
using OpenTelemetry.Exporter;
4
using OpenTelemetry.Logs;
5
using OpenTelemetry.Metrics;
6
using OpenTelemetry.Resources;
7
using OpenTelemetry.Trace;
8
using Serilog.Context;
9
using Serilog.Core;
10
using Serilog.Events;
11
using Serilog.Sinks.OpenTelemetry;
12
13
namespace dotnet;
14
15
public class HighlightTraceProcessor : BaseProcessor<Activity>
16
{
17
    public override void OnStart(Activity data)
18
    {
19
        var ctx = HighlightConfig.GetHighlightContext();
20
        foreach (var entry in ctx)
21
        {
22
            data.SetTag(entry.Key, entry.Value);
23
        }
24
25
        base.OnStart(data);
26
    }
27
}
28
29
public class HighlightLogProcessor : BaseProcessor<LogRecord>
30
{
31
    public override void OnStart(LogRecord data)
32
    {
33
        var ctx = HighlightConfig.GetHighlightContext();
34
        var attributes = ctx.Select(entry => new KeyValuePair<string, object?>(entry.Key, entry.Value)).ToList();
35
        if (data.Attributes != null)
36
        {
37
            attributes = attributes.Concat(data.Attributes).ToList();
38
        }
39
40
        data.Attributes = attributes;
41
        base.OnStart(data);
42
    }
43
}
44
45
public class HighlightLogEnricher : ILogEventEnricher
46
{
47
    public void Enrich(LogEvent logEvent, ILogEventPropertyFactory pf)
48
    {
49
        var ctx = HighlightConfig.GetHighlightContext();
50
        foreach (var entry in ctx)
51
        {
52
            logEvent.AddOrUpdateProperty(pf.CreateProperty(entry.Key, entry.Value));
53
        }
54
    }
55
}
56
57
public class HighlightConfig
58
{
59
    // Replace with the highlight endpoint. For highlight.io cloud, use https://otel.highlight.io:4318
60
    public static readonly String OtlpEndpoint = "https://otel.highlight.io:4318";
61
62
    // Replace with your project ID and service name.
63
    public static readonly String ProjectId = "<YOUR_PROJECT_ID>";
64
    // This must match the ServiceName used by the ActivitySource to ensure traces are sent.
65
    public static readonly String ServiceName = "highlight-dot-net-example";
66
67
    public static readonly String TracesEndpoint = OtlpEndpoint + "/v1/traces";
68
    public static readonly String LogsEndpoint = OtlpEndpoint + "/v1/logs";
69
    public static readonly String MetricsEndpoint = OtlpEndpoint + "/v1/metrics";
70
71
    public static readonly OtlpProtocol Protocol = OtlpProtocol.HttpProtobuf;
72
    public static readonly OtlpExportProtocol ExportProtocol = OtlpExportProtocol.HttpProtobuf;
73
    public static readonly String HighlightHeader = "x-highlight-request";
74
75
    public static readonly Dictionary<string, object> ResourceAttributes = new()
76
    {
77
        ["highlight.project_id"] = ProjectId,
78
        ["service.name"] = ServiceName,
79
    };
80
81
    public static Dictionary<string, string> GetHighlightContext()
82
    {
83
        var ctx = new Dictionary<string, string>
84
        {
85
            { "highlight.project_id", ProjectId },
86
        };
87
88
        var headerValue = Baggage.GetBaggage(HighlightHeader);
89
        if (headerValue == null) return ctx;
90
91
        var parts = headerValue.Split("/");
92
        if (parts.Length < 2) return ctx;
93
94
        ctx["highlight.session_id"] = parts[0];
95
        ctx["highlight.trace_id"] = parts[1];
96
        return ctx;
97
    }
98
99
    public static void EnrichWithHttpRequest(Activity activity, HttpRequest httpRequest)
100
    {
101
        var headerValues = httpRequest.Headers[HighlightHeader];
102
        if (headerValues.Count < 1) return;
103
        var headerValue = headerValues[0];
104
        if (headerValue == null) return;
105
        var parts = headerValue.Split("/");
106
        if (parts?.Length < 2) return;
107
        activity.SetTag("highlight.session_id", parts?[0]);
108
        activity.SetTag("highlight.trace_id", parts?[1]);
109
        Baggage.SetBaggage(new KeyValuePair<string, string>[]
110
        {
111
            new(HighlightHeader, headerValue)
112
        });
113
    }
114
115
    public static void Configure(WebApplicationBuilder builder)
116
    {
117
        builder.Logging.AddOpenTelemetry(options =>
118
        {
119
            options
120
                .SetResourceBuilder(ResourceBuilder.CreateDefault().AddAttributes(ResourceAttributes))
121
                .AddProcessor(new HighlightLogProcessor())
122
                .AddOtlpExporter(exporterOptions =>
123
                {
124
                    exporterOptions.Endpoint = new Uri(LogsEndpoint);
125
                    exporterOptions.Protocol = ExportProtocol;
126
                });
127
        });
128
129
        builder.Services.AddOpenTelemetry()
130
            .ConfigureResource(resource => resource.AddAttributes(ResourceAttributes))
131
            .WithTracing(tracing => tracing
132
                .AddSource(ServiceName)
133
                .AddProcessor(new HighlightTraceProcessor())
134
                .AddAspNetCoreInstrumentation(options =>
135
                {
136
                    options.RecordException = true;
137
                    options.EnrichWithHttpRequest = EnrichWithHttpRequest;
138
                })
139
                .AddOtlpExporter(options =>
140
                {
141
                    options.Endpoint = new Uri(TracesEndpoint);
142
                    options.Protocol = ExportProtocol;
143
                }))
144
            .WithMetrics(metrics => metrics
145
                .AddMeter(ServiceName)
146
                .AddAspNetCoreInstrumentation()
147
                .AddOtlpExporter(options =>
148
                {
149
                    options.Endpoint = new Uri(MetricsEndpoint);
150
                    options.Protocol = ExportProtocol;
151
                }));
152
    }
153
}

1
var config = new NLog.Config.LoggingConfiguration();
2
var logfile = new NLog.Targets.FileTarget("logfile") { FileName = "file.txt" };
3
var logconsole = new NLog.Targets.ConsoleTarget("logconsole");
4
5
config.AddRule(LogLevel.Info, LogLevel.Fatal, logconsole);
6
config.AddRule(LogLevel.Debug, LogLevel.Fatal, logfile);
7
8
NLog.LogManager.Configuration = config;