Split InstrumentationOptions for Trace and Meter

Author: MattKotsenas

src/OpenTelemetry.Instrumentation.Kusto/.publicApi/PublicAPI.Unshipped.txt

@@ -1,15 +1,21 @@
 #nullable enable
-OpenTelemetry.Instrumentation.Kusto.KustoInstrumentationOptions
-OpenTelemetry.Instrumentation.Kusto.KustoInstrumentationOptions.Enrich.get -> System.Action<System.Diagnostics.Activity!, Kusto.Cloud.Platform.Utils.TraceRecord!>?
-OpenTelemetry.Instrumentation.Kusto.KustoInstrumentationOptions.Enrich.set -> void
-OpenTelemetry.Instrumentation.Kusto.KustoInstrumentationOptions.KustoInstrumentationOptions() -> void
-OpenTelemetry.Instrumentation.Kusto.KustoInstrumentationOptions.RecordQuerySummary.get -> bool
-OpenTelemetry.Instrumentation.Kusto.KustoInstrumentationOptions.RecordQuerySummary.set -> void
-OpenTelemetry.Instrumentation.Kusto.KustoInstrumentationOptions.RecordQueryText.get -> bool
-OpenTelemetry.Instrumentation.Kusto.KustoInstrumentationOptions.RecordQueryText.set -> void
+OpenTelemetry.Metrics.KustoMeterInstrumentationOptions
+OpenTelemetry.Metrics.KustoMeterInstrumentationOptions.KustoMeterInstrumentationOptions() -> void
+OpenTelemetry.Metrics.KustoMeterInstrumentationOptions.RecordQuerySummary.get -> bool
+OpenTelemetry.Metrics.KustoMeterInstrumentationOptions.RecordQuerySummary.set -> void
+OpenTelemetry.Metrics.KustoMeterInstrumentationOptions.RecordQueryText.get -> bool
+OpenTelemetry.Metrics.KustoMeterInstrumentationOptions.RecordQueryText.set -> void
 OpenTelemetry.Metrics.MeterProviderBuilderExtensions
+OpenTelemetry.Trace.KustoTraceInstrumentationOptions
+OpenTelemetry.Trace.KustoTraceInstrumentationOptions.Enrich.get -> System.Action<System.Diagnostics.Activity!, Kusto.Cloud.Platform.Utils.TraceRecord!>?
+OpenTelemetry.Trace.KustoTraceInstrumentationOptions.Enrich.set -> void
+OpenTelemetry.Trace.KustoTraceInstrumentationOptions.KustoTraceInstrumentationOptions() -> void
+OpenTelemetry.Trace.KustoTraceInstrumentationOptions.RecordQuerySummary.get -> bool
+OpenTelemetry.Trace.KustoTraceInstrumentationOptions.RecordQuerySummary.set -> void
+OpenTelemetry.Trace.KustoTraceInstrumentationOptions.RecordQueryText.get -> bool
+OpenTelemetry.Trace.KustoTraceInstrumentationOptions.RecordQueryText.set -> void
 OpenTelemetry.Trace.TracerProviderBuilderExtensions
 static OpenTelemetry.Metrics.MeterProviderBuilderExtensions.AddKustoInstrumentation(this OpenTelemetry.Metrics.MeterProviderBuilder! builder) -> OpenTelemetry.Metrics.MeterProviderBuilder!
-static OpenTelemetry.Metrics.MeterProviderBuilderExtensions.AddKustoInstrumentation(this OpenTelemetry.Metrics.MeterProviderBuilder! builder, System.Action<OpenTelemetry.Instrumentation.Kusto.KustoInstrumentationOptions!>! configureKustoInstrumentationOptions) -> OpenTelemetry.Metrics.MeterProviderBuilder!
+static OpenTelemetry.Metrics.MeterProviderBuilderExtensions.AddKustoInstrumentation(this OpenTelemetry.Metrics.MeterProviderBuilder! builder, System.Action<OpenTelemetry.Metrics.KustoMeterInstrumentationOptions!>? configureKustoMeterInstrumentationOptions) -> OpenTelemetry.Metrics.MeterProviderBuilder!
 static OpenTelemetry.Trace.TracerProviderBuilderExtensions.AddKustoInstrumentation(this OpenTelemetry.Trace.TracerProviderBuilder! builder) -> OpenTelemetry.Trace.TracerProviderBuilder!
-static OpenTelemetry.Trace.TracerProviderBuilderExtensions.AddKustoInstrumentation(this OpenTelemetry.Trace.TracerProviderBuilder! builder, System.Action<OpenTelemetry.Instrumentation.Kusto.KustoInstrumentationOptions!>! configureKustoInstrumentationOptions) -> OpenTelemetry.Trace.TracerProviderBuilder!
+static OpenTelemetry.Trace.TracerProviderBuilderExtensions.AddKustoInstrumentation(this OpenTelemetry.Trace.TracerProviderBuilder! builder, System.Action<OpenTelemetry.Trace.KustoTraceInstrumentationOptions!>? configureKustoTraceInstrumentationOptions) -> OpenTelemetry.Trace.TracerProviderBuilder!

src/OpenTelemetry.Instrumentation.Kusto/Implementation/ActivityExtensions.cs

@@ -15,10 +15,7 @@ internal static class InstrumentationHandleManagerExtensions
     /// The <see cref="InstrumentationHandleManager"/> to check for active tracing handles.
     /// </param>
     /// <returns><see langword="true"/> if tracing is active; otherwise, <see langword="false"/>.</returns>
-    public static bool IsTracingActive(this InstrumentationHandleManager handleManager)
-    {
-        return handleManager.TracingHandles > 0;
-    }
+    public static bool IsTracingActive(this InstrumentationHandleManager handleManager) => handleManager.TracingHandles > 0;
 
     /// <summary>
     /// Returns <see langword="true"/> if metrics is active (i.e., there is at least one metrics handle); otherwise, <see langword="false"/>.
@@ -27,8 +24,5 @@ public static bool IsTracingActive(this InstrumentationHandleManager handleManag
     /// The <see cref="InstrumentationHandleManager"/> to check for active metrics handles.
     /// </param>
     /// <returns><see langword="true"/> if metrics is active; otherwise, <see langword="false"/>.</returns>
-    public static bool IsMetricsActive(this InstrumentationHandleManager handleManager)
-    {
-        return handleManager.MetricHandles > 0;
-    }
+    public static bool IsMetricsActive(this InstrumentationHandleManager handleManager) => handleManager.MetricHandles > 0;
 }

src/OpenTelemetry.Instrumentation.Kusto/Implementation/InstrumentationHandleManagerExtensions.cs

@@ -2,6 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 using Kusto.Cloud.Platform.Utils;
+using OpenTelemetry.Metrics;
+using OpenTelemetry.Trace;
 
 namespace OpenTelemetry.Instrumentation.Kusto.Implementation;
 
@@ -21,14 +23,22 @@ internal static class KustoInstrumentation
     });
 
     /// <summary>
-    /// Gets the post-configured options for Kusto instrumentation.
+    /// Gets or sets the post-configured trace options for Kusto instrumentation.
     /// </summary>
-    public static KustoInstrumentationOptions Options { get; } = new KustoInstrumentationOptions();
+    public static KustoTraceInstrumentationOptions TraceOptions { get; set; } = new KustoTraceInstrumentationOptions();
+
+    /// <summary>
+    /// Gets or sets the post-configured meter options for Kusto instrumentation.
+    /// </summary>
+    public static KustoMeterInstrumentationOptions MeterOptions { get; set; } = new KustoMeterInstrumentationOptions();
 
     /// <summary>
     /// Gets the <see cref="InstrumentationHandleManager"/> that tracks if there are any active listeners for <see cref="KustoTraceRecordListener"/>.
     /// </summary>
     public static InstrumentationHandleManager HandleManager { get; } = new InstrumentationHandleManager();
 
+    /// <summary>
+    /// Initializes the Kusto instrumentation by ensuring the listener is created and registered with the client library.
+    /// </summary>
     public static void Initialize() => _ = Listener.Value;
 }

src/OpenTelemetry.Instrumentation.Kusto/Implementation/KustoInstrumentation.cs

@@ -24,22 +24,13 @@ public void EnrichmentException(Exception ex)
     }
 
     [Event(1, Message = "Enrichment exception: {0}", Level = EventLevel.Error)]
-    public void EnrichmentException(string exception)
-    {
-        this.WriteEvent(1, exception);
-    }
+    public void EnrichmentException(string exception) => this.WriteEvent(1, exception);
 
     [Event(2, Message = "Trace record payload is NULL or has NULL message, record will not be processed.", Level = EventLevel.Warning)]
-    public void NullPayload()
-    {
-        this.WriteEvent(2);
-    }
+    public void NullPayload() => this.WriteEvent(2);
 
     [Event(3, Message = "Failed to find context for activity ID '{0}', operation data will not be recorded.", Level = EventLevel.Warning)]
-    public void ContextNotFound(string activityId)
-    {
-        this.WriteEvent(3, activityId);
-    }
+    public void ContextNotFound(string activityId) => this.WriteEvent(3, activityId);
 
     [NonEvent]
     public void UnknownErrorProcessingTraceRecord(Exception ex)
@@ -51,8 +42,5 @@ public void UnknownErrorProcessingTraceRecord(Exception ex)
     }
 
     [Event(4, Message = "Unknown error processing trace record, Exception: {0}", Level = EventLevel.Error)]
-    public void UnknownErrorProcessingTraceRecord(string exception)
-    {
-        this.WriteEvent(4, exception);
-    }
+    public void UnknownErrorProcessingTraceRecord(string exception) => this.WriteEvent(4, exception);
 }

src/OpenTelemetry.Instrumentation.Kusto/Implementation/KustoInstrumentationEventSource.cs

@@ -88,7 +88,7 @@ private void CallEnrichment(KustoUtils.TraceRecord record)
             var activity = this.GetContext(record)?.Activity;
             if (activity is not null && activity.IsAllDataRequested)
             {
-                KustoInstrumentation.Options.Enrich?.Invoke(activity, record);
+                KustoInstrumentation.TraceOptions.Enrich?.Invoke(activity, record);
             }
         }
         catch (Exception ex)
@@ -110,7 +110,7 @@ private void HandleException(KustoUtils.TraceRecord record)
         if (!result.ErrorType.IsEmpty)
         {
             activity?.SetTag(SemanticConventions.AttributeErrorType, result.ErrorType.ToString());
-            context.Value.Tags.Add(SemanticConventions.AttributeErrorType, result.ErrorType.ToString());
+            context.Value.MeterTags.Add(SemanticConventions.AttributeErrorType, result.ErrorType.ToString());
         }
 
         var description = result.ErrorMessage.IsEmpty ? null : result.ErrorMessage.ToString();
@@ -125,52 +125,74 @@ private void HandleHttpRequestStart(KustoUtils.TraceRecord record)
         var operationName = record.Activity.ActivityType;
 
         var activity = KustoActivitySourceHelper.ActivitySource.StartActivity(operationName, ActivityKind.Client);
-        var tagList = default(TagList);
+        var meterTags = default(TagList);
 
         if (ShouldComputeTags(activity))
         {
             activity?.DisplayName = operationName;
             activity?.AddTag(KustoActivitySourceHelper.ClientRequestIdTagKey, record.Activity.ClientRequestId.ToString());
 
-            tagList.Add(SemanticConventions.AttributeDbSystemName, KustoActivitySourceHelper.DbSystem);
-            tagList.Add(SemanticConventions.AttributeDbOperationName, operationName);
+            activity?.AddTag(SemanticConventions.AttributeDbSystemName, KustoActivitySourceHelper.DbSystem);
+            activity?.AddTag(SemanticConventions.AttributeDbOperationName, operationName);
+            meterTags.Add(SemanticConventions.AttributeDbSystemName, KustoActivitySourceHelper.DbSystem);
+            meterTags.Add(SemanticConventions.AttributeDbOperationName, operationName);
 
             var result = TraceRecordParser.ParseRequestStart(record.Message.AsSpan());
 
             if (!string.IsNullOrEmpty(result.ServerAddress))
             {
-                tagList.Add(SemanticConventions.AttributeServerAddress, result.ServerAddress);
+                activity?.AddTag(SemanticConventions.AttributeServerAddress, result.ServerAddress);
+                meterTags.Add(SemanticConventions.AttributeServerAddress, result.ServerAddress);
             }
 
             if (result.ServerPort is not null)
             {
-                tagList.Add(SemanticConventions.AttributeServerPort, result.ServerPort.Value);
+                activity?.AddTag(SemanticConventions.AttributeServerPort, result.ServerPort.Value);
+                meterTags.Add(SemanticConventions.AttributeServerPort, result.ServerPort.Value);
             }
 
             if (!result.Database.IsEmpty)
             {
-                tagList.Add(SemanticConventions.AttributeDbNamespace, result.Database.ToString());
+                activity?.AddTag(SemanticConventions.AttributeDbNamespace, result.Database.ToString());
+                meterTags.Add(SemanticConventions.AttributeDbNamespace, result.Database.ToString());
             }
 
             if (!result.QueryText.IsEmpty)
             {
-                var info = KustoProcessor.Process(shouldSummarize: KustoInstrumentation.Options.RecordQuerySummary, shouldSanitize: KustoInstrumentation.Options.RecordQueryText, result.QueryText.ToString());
+                var shouldSummarize = KustoInstrumentation.TraceOptions.RecordQuerySummary || KustoInstrumentation.MeterOptions.RecordQuerySummary;
+                var shouldSanitize = KustoInstrumentation.TraceOptions.RecordQueryText || KustoInstrumentation.MeterOptions.RecordQueryText;
+                var info = KustoProcessor.Process(shouldSummarize, shouldSanitize, result.QueryText.ToString());
 
-                if (KustoInstrumentation.Options.RecordQueryText)
+                if (!string.IsNullOrEmpty(info.Sanitized))
                 {
-                    tagList.Add(SemanticConventions.AttributeDbQueryText, info.Sanitized);
+                    if (KustoInstrumentation.TraceOptions.RecordQueryText)
+                    {
+                        activity?.AddTag(SemanticConventions.AttributeDbQueryText, info.Sanitized);
+                    }
+
+                    if (KustoInstrumentation.MeterOptions.RecordQueryText)
+                    {
+                        meterTags.Add(SemanticConventions.AttributeDbQueryText, info.Sanitized);
+                    }
                 }
 
-                // Set query summary and use it as display name per spec
                 if (!string.IsNullOrEmpty(info.Summarized))
                 {
-                    tagList.Add(SemanticConventions.AttributeDbQuerySummary, info.Summarized);
-                    activity?.DisplayName = info.Summarized!;
+                    if (KustoInstrumentation.TraceOptions.RecordQuerySummary)
+                    {
+                        activity?.AddTag(SemanticConventions.AttributeDbQuerySummary, info.Summarized);
+                        activity?.DisplayName = info.Summarized!;
+                    }
+
+                    if (KustoInstrumentation.MeterOptions.RecordQuerySummary)
+                    {
+                        meterTags.Add(SemanticConventions.AttributeDbQuerySummary, info.Summarized);
+                    }
                 }
             }
         }
 
-        this.contexts[record.Activity.ActivityId] = new ContextData(beginTimestamp, tagList, activity!);
+        this.contexts[record.Activity.ActivityId] = new ContextData(beginTimestamp, meterTags, activity!);
 
         this.CallEnrichment(record);
     }
@@ -191,12 +213,11 @@ private void HandleActivityComplete(KustoUtils.TraceRecord record)
             activity?.SetStatus(ActivityStatusCode.Ok);
         }
 
-        activity?.AddTags(context.Value.Tags);
         this.CallEnrichment(record);
         activity?.Stop();
 
         var duration = activity?.Duration.TotalSeconds ?? GetElapsedTime(context.Value.BeginTimestamp);
-        KustoActivitySourceHelper.OperationDurationHistogram.Record(duration, context.Value.Tags);
+        KustoActivitySourceHelper.OperationDurationHistogram.Record(duration, context.Value.MeterTags);
 
         this.contexts.TryRemove(record.Activity.ActivityId, out _);
     }
@@ -217,10 +238,10 @@ private void HandleActivityComplete(KustoUtils.TraceRecord record)
     /// </summary>
     private readonly struct ContextData
     {
-        public ContextData(long beginTimestamp, TagList tags, Activity activity)
+        public ContextData(long beginTimestamp, TagList meterTags, Activity activity)
         {
             this.BeginTimestamp = beginTimestamp;
-            this.Tags = tags;
+            this.MeterTags = meterTags;
             this.Activity = activity;
         }
 
@@ -231,9 +252,9 @@ public ContextData(long beginTimestamp, TagList tags, Activity activity)
         public long BeginTimestamp { get; }
 
         /// <summary>
-        /// Gets the collection of tags associated with the operation that should be shared between the span and metrics.
+        /// Gets the collection of tags associated with the operation that should be applies to metrics.
         /// </summary>
-        public TagList Tags { get; }
+        public TagList MeterTags { get; }
 
         /// <summary>
         /// Gets the current activity associated with the instance, if any.

src/OpenTelemetry.Instrumentation.Kusto/Implementation/KustoTraceRecordListener.cs

@@ -0,0 +1,22 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+namespace OpenTelemetry.Metrics;
+
+/// <summary>
+/// Options for Kusto meter instrumentation.
+/// </summary>
+public sealed class KustoMeterInstrumentationOptions
+{
+    /// <summary>
+    /// Gets or sets a value indicating whether the query text should be recorded as an attribute on the activity.
+    /// Default is <see langword="false"/>.
+    /// </summary>
+    public bool RecordQueryText { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether a summary of the query should be recorded as an attribute on the activity.
+    /// Default is <see langword="true"/>.
+    /// </summary>
+    public bool RecordQuerySummary { get; set; } = true;
+}

src/OpenTelemetry.Instrumentation.Kusto/KustoMeterInstrumentationOptions.cs

@@ -4,12 +4,12 @@
 using System.Diagnostics;
 using KustoUtils = Kusto.Cloud.Platform.Utils;
 
-namespace OpenTelemetry.Instrumentation.Kusto;
+namespace OpenTelemetry.Trace;
 
 /// <summary>
-/// Options for Kusto instrumentation.
+/// Options for Kusto trace instrumentation.
 /// </summary>
-public class KustoInstrumentationOptions
+public sealed class KustoTraceInstrumentationOptions
 {
     /// <summary>
     /// Gets or sets a value indicating whether the query text should be recorded as an attribute on the activity.