diff --git a/NOTICE.txt b/NOTICE.txt index 2d6823795a04..01a06a82faf9 100644 --- a/NOTICE.txt +++ b/NOTICE.txt @@ -228,3 +228,20 @@ The attached notices are provided for information only. WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. + +License notice for OpenTelemetry .NET (https://github.com/open-telemetry/opentelemetry-dotnet) +---------------------------------------------------------------------------------------------- + +Copyright 2023 OpenTelemetry Authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Azure.Monitor.OpenTelemetry.AspNetCore.csproj b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Azure.Monitor.OpenTelemetry.AspNetCore.csproj index ad344077dff8..0a03edeff236 100644 --- a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Azure.Monitor.OpenTelemetry.AspNetCore.csproj +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Azure.Monitor.OpenTelemetry.AspNetCore.csproj @@ -6,14 +6,17 @@ Azure Monitor OpenTelemetry Exporter Distro ApplicationInsights $(RequiredTargetFrameworks) true + SA1636 + + disable - - - + + + @@ -24,4 +27,5 @@ + diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/DefaultAzureMonitorOptions.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/DefaultAzureMonitorOptions.cs index c9f1102ed739..5eedcab9afe0 100644 --- a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/DefaultAzureMonitorOptions.cs +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/DefaultAzureMonitorOptions.cs @@ -1,6 +1,8 @@ // Copyright (c) Microsoft Corporation. All rights reserved. // Licensed under the MIT License. +#nullable enable + using System; using Microsoft.Extensions.Configuration; using Microsoft.Extensions.Options; diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/AspNetCoreInstrumentation.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/AspNetCoreInstrumentation.cs new file mode 100644 index 000000000000..a5010acf46b5 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/AspNetCoreInstrumentation.cs @@ -0,0 +1,55 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using System.Collections.Generic; +using OpenTelemetry.Instrumentation.AspNetCore.Implementation; + +namespace OpenTelemetry.Instrumentation.AspNetCore +{ + /// + /// Asp.Net Core Requests instrumentation. + /// + internal sealed class AspNetCoreInstrumentation : IDisposable + { + private static readonly HashSet DiagnosticSourceEvents = new() + { + "Microsoft.AspNetCore.Hosting.HttpRequestIn", + "Microsoft.AspNetCore.Hosting.HttpRequestIn.Start", + "Microsoft.AspNetCore.Hosting.HttpRequestIn.Stop", + "Microsoft.AspNetCore.Mvc.BeforeAction", + "Microsoft.AspNetCore.Diagnostics.UnhandledException", + "Microsoft.AspNetCore.Hosting.UnhandledException", + }; + + private readonly Func isEnabled = (eventName, _, _) + => DiagnosticSourceEvents.Contains(eventName); + + private readonly DiagnosticSourceSubscriber diagnosticSourceSubscriber; + + public AspNetCoreInstrumentation(HttpInListener httpInListener) + { + this.diagnosticSourceSubscriber = new DiagnosticSourceSubscriber(httpInListener, this.isEnabled); + this.diagnosticSourceSubscriber.Subscribe(); + } + + /// + public void Dispose() + { + this.diagnosticSourceSubscriber?.Dispose(); + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/AspNetCoreInstrumentationOptions.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/AspNetCoreInstrumentationOptions.cs new file mode 100644 index 000000000000..1916289ebe69 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/AspNetCoreInstrumentationOptions.cs @@ -0,0 +1,110 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using System.Diagnostics; +using Microsoft.AspNetCore.Http; +using Microsoft.Extensions.Configuration; +using static OpenTelemetry.Internal.HttpSemanticConventionHelper; + +namespace OpenTelemetry.Instrumentation.AspNetCore +{ + /// + /// Options for requests instrumentation. + /// + internal class AspNetCoreInstrumentationOptions + { + internal readonly HttpSemanticConvention HttpSemanticConvention; + + /// + /// Initializes a new instance of the class. + /// + public AspNetCoreInstrumentationOptions() + : this(new ConfigurationBuilder().AddEnvironmentVariables().Build()) + { + } + + internal AspNetCoreInstrumentationOptions(IConfiguration configuration) + { + Debug.Assert(configuration != null, "configuration was null"); + + this.HttpSemanticConvention = GetSemanticConventionOptIn(configuration); + } + + /// + /// Gets or sets a filter function that determines whether or not to + /// collect telemetry on a per request basis. + /// + /// + /// Notes: + /// + /// The return value for the filter function is interpreted as: + /// + /// If filter returns , the request is + /// collected. + /// If filter returns or throws an + /// exception the request is NOT collected. + /// + /// + /// + public Func Filter { get; set; } + + /// + /// Gets or sets an action to enrich an Activity. + /// + /// + /// : the activity being enriched. + /// : the HttpRequest object from which additional information can be extracted to enrich the activity. + /// + public Action EnrichWithHttpRequest { get; set; } + + /// + /// Gets or sets an action to enrich an Activity. + /// + /// + /// : the activity being enriched. + /// : the HttpResponse object from which additional information can be extracted to enrich the activity. + /// + public Action EnrichWithHttpResponse { get; set; } + + /// + /// Gets or sets an action to enrich an Activity. + /// + /// + /// : the activity being enriched. + /// : the Exception object from which additional information can be extracted to enrich the activity. + /// + public Action EnrichWithException { get; set; } + + /// + /// Gets or sets a value indicating whether the exception will be recorded as ActivityEvent or not. + /// + /// + /// https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/semantic_conventions/exceptions.md. + /// + public bool RecordException { get; set; } + +#if NETSTANDARD2_1 || NET6_0_OR_GREATER + /// + /// Gets or sets a value indicating whether RPC attributes are added to an Activity when using Grpc.AspNetCore. Default is true. + /// + /// + /// https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/semantic_conventions/rpc.md. + /// + public bool EnableGrpcAspNetCoreSupport { get; set; } = true; +#endif + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/AspNetCoreMetrics.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/AspNetCoreMetrics.cs new file mode 100644 index 000000000000..eb947b9f7dba --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/AspNetCoreMetrics.cs @@ -0,0 +1,64 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using System.Collections.Generic; +using System.Diagnostics.Metrics; +using System.Reflection; +using OpenTelemetry.Instrumentation.AspNetCore.Implementation; +using OpenTelemetry.Internal; + +namespace OpenTelemetry.Instrumentation.AspNetCore +{ + /// + /// Asp.Net Core Requests instrumentation. + /// + internal sealed class AspNetCoreMetrics : IDisposable + { + internal static readonly AssemblyName AssemblyName = typeof(HttpInListener).Assembly.GetName(); + internal static readonly string InstrumentationName = AssemblyName.Name; + internal static readonly string InstrumentationVersion = AssemblyName.Version.ToString(); + + private static readonly HashSet DiagnosticSourceEvents = new() + { + "Microsoft.AspNetCore.Hosting.HttpRequestIn", + "Microsoft.AspNetCore.Hosting.HttpRequestIn.Start", + "Microsoft.AspNetCore.Hosting.HttpRequestIn.Stop", + }; + + private readonly Func isEnabled = (eventName, _, _) + => DiagnosticSourceEvents.Contains(eventName); + + private readonly DiagnosticSourceSubscriber diagnosticSourceSubscriber; + private readonly Meter meter; + + internal AspNetCoreMetrics(AspNetCoreMetricsInstrumentationOptions options) + { + Guard.ThrowIfNull(options); + this.meter = new Meter(InstrumentationName, InstrumentationVersion); + var metricsListener = new HttpInMetricsListener("Microsoft.AspNetCore", this.meter, options); + this.diagnosticSourceSubscriber = new DiagnosticSourceSubscriber(metricsListener, this.isEnabled); + this.diagnosticSourceSubscriber.Subscribe(); + } + + /// + public void Dispose() + { + this.diagnosticSourceSubscriber?.Dispose(); + this.meter?.Dispose(); + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/AspNetCoreMetricsInstrumentationOptions.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/AspNetCoreMetricsInstrumentationOptions.cs new file mode 100644 index 000000000000..b301a2c7d4ec --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/AspNetCoreMetricsInstrumentationOptions.cs @@ -0,0 +1,80 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using System.Diagnostics; +using Microsoft.AspNetCore.Http; +using Microsoft.Extensions.Configuration; +using static OpenTelemetry.Internal.HttpSemanticConventionHelper; + +namespace OpenTelemetry.Instrumentation.AspNetCore +{ + /// + /// Options for metrics requests instrumentation. + /// + internal class AspNetCoreMetricsInstrumentationOptions + { + internal readonly HttpSemanticConvention HttpSemanticConvention; + + /// + /// Initializes a new instance of the class. + /// + public AspNetCoreMetricsInstrumentationOptions() + : this(new ConfigurationBuilder().AddEnvironmentVariables().Build()) + { + } + + internal AspNetCoreMetricsInstrumentationOptions(IConfiguration configuration) + { + Debug.Assert(configuration != null, "configuration was null"); + + this.HttpSemanticConvention = GetSemanticConventionOptIn(configuration); + } + + /// + /// Delegate for enrichment of recorded metric with additional tags. + /// + /// The name of the metric being enriched. + /// : the HttpContext object. Both Request and Response are available. + /// : List of current tags. You can add additional tags to this list. + public delegate void AspNetCoreMetricEnrichmentFunc(string name, HttpContext context, ref TagList tags); + + /// + /// Gets or sets a filter function that determines whether or not to + /// collect telemetry on a per request basis. + /// + /// + /// Notes: + /// + /// The first parameter is the name of the metric being + /// filtered. + /// The return value for the filter function is interpreted as: + /// + /// If filter returns , the request is + /// collected. + /// If filter returns or throws an + /// exception the request is NOT collected. + /// + /// + /// + public Func Filter { get; set; } + + /// + /// Gets or sets an function to enrich a recorded metric with additional custom tags. + /// + public AspNetCoreMetricEnrichmentFunc Enrich { get; set; } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/Implementation/AspNetCoreInstrumentationEventSource.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/Implementation/AspNetCoreInstrumentationEventSource.cs new file mode 100644 index 000000000000..e41f6d88549d --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/Implementation/AspNetCoreInstrumentationEventSource.cs @@ -0,0 +1,76 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using System.Diagnostics.CodeAnalysis; +using System.Diagnostics.Tracing; +using OpenTelemetry.Internal; + +namespace OpenTelemetry.Instrumentation.AspNetCore.Implementation +{ + /// + /// EventSource events emitted from the project. + /// + [EventSource(Name = "OpenTelemetry-Instrumentation-AspNetCore")] + internal sealed class AspNetCoreInstrumentationEventSource : EventSource + { + public static AspNetCoreInstrumentationEventSource Log = new(); + + [NonEvent] + public void RequestFilterException(string handlerName, string eventName, string operationName, Exception ex) + { + if (this.IsEnabled(EventLevel.Error, EventKeywords.All)) + { + this.RequestFilterException(handlerName, eventName, operationName, ex.ToInvariantString()); + } + } + + [NonEvent] + public void EnrichmentException(string handlerName, string eventName, string operationName, Exception ex) + { + if (this.IsEnabled(EventLevel.Error, EventKeywords.All)) + { + this.EnrichmentException(handlerName, eventName, operationName, ex.ToInvariantString()); + } + } + + [Event(1, Message = "Payload is NULL, span will not be recorded. HandlerName: '{0}', EventName: '{1}', OperationName: '{2}'.", Level = EventLevel.Warning)] + public void NullPayload(string handlerName, string eventName, string operationName) + { + this.WriteEvent(1, handlerName, eventName, operationName); + } + + [Event(2, Message = "Request is filtered out. HandlerName: '{0}', EventName: '{1}', OperationName: '{2}'.", Level = EventLevel.Verbose)] + public void RequestIsFilteredOut(string handlerName, string eventName, string operationName) + { + this.WriteEvent(2, handlerName, eventName, operationName); + } + + [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "Parameters to this method are primitive and are trimmer safe.")] + [Event(3, Message = "Filter threw exception, request will not be collected. HandlerName: '{0}', EventName: '{1}', OperationName: '{2}', Exception: {3}.", Level = EventLevel.Error)] + public void RequestFilterException(string handlerName, string eventName, string operationName, string exception) + { + this.WriteEvent(3, handlerName, eventName, operationName, exception); + } + + [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:RequiresUnreferencedCode", Justification = "Parameters to this method are primitive and are trimmer safe.")] + [Event(4, Message = "Enrich threw exception. HandlerName: '{0}', EventName: '{1}', OperationName: '{2}', Exception: {3}.", Level = EventLevel.Warning)] + public void EnrichmentException(string handlerName, string eventName, string operationName, string exception) + { + this.WriteEvent(4, handlerName, eventName, operationName, exception); + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/Implementation/HttpInListener.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/Implementation/HttpInListener.cs new file mode 100644 index 000000000000..5acb988ac23b --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/Implementation/HttpInListener.cs @@ -0,0 +1,544 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Reflection; +#if !NETSTANDARD2_0 +using System.Runtime.CompilerServices; +#endif +using Microsoft.AspNetCore.Http; +#if NET6_0_OR_GREATER +using Microsoft.AspNetCore.Mvc.Diagnostics; +#endif +using OpenTelemetry.Context.Propagation; +#if !NETSTANDARD2_0 +using OpenTelemetry.Instrumentation.GrpcNetClient; +#endif +using OpenTelemetry.Internal; +using OpenTelemetry.Trace; +using static OpenTelemetry.Internal.HttpSemanticConventionHelper; + +namespace OpenTelemetry.Instrumentation.AspNetCore.Implementation +{ + internal class HttpInListener : ListenerHandler + { + internal const string ActivityOperationName = "Microsoft.AspNetCore.Hosting.HttpRequestIn"; + internal const string OnStartEvent = "Microsoft.AspNetCore.Hosting.HttpRequestIn.Start"; + internal const string OnStopEvent = "Microsoft.AspNetCore.Hosting.HttpRequestIn.Stop"; + internal const string OnMvcBeforeActionEvent = "Microsoft.AspNetCore.Mvc.BeforeAction"; + internal const string OnUnhandledHostingExceptionEvent = "Microsoft.AspNetCore.Hosting.UnhandledException"; + internal const string OnUnHandledDiagnosticsExceptionEvent = "Microsoft.AspNetCore.Diagnostics.UnhandledException"; + +#if NET7_0_OR_GREATER + // https://github.com/dotnet/aspnetcore/blob/8d6554e655b64da75b71e0e20d6db54a3ba8d2fb/src/Hosting/Hosting/src/GenericHost/GenericWebHostBuilder.cs#L85 + internal static readonly string AspNetCoreActivitySourceName = "Microsoft.AspNetCore"; +#endif + + internal static readonly AssemblyName AssemblyName = typeof(HttpInListener).Assembly.GetName(); + internal static readonly string ActivitySourceName = AssemblyName.Name; + internal static readonly Version Version = AssemblyName.Version; + internal static readonly ActivitySource ActivitySource = new(ActivitySourceName, Version.ToString()); + + private const string DiagnosticSourceName = "Microsoft.AspNetCore"; + private const string UnknownHostName = "UNKNOWN-HOST"; + + private static readonly Func> HttpRequestHeaderValuesGetter = (request, name) => request.Headers[name]; +#if !NET6_0_OR_GREATER + private readonly PropertyFetcher beforeActionActionDescriptorFetcher = new("actionDescriptor"); + private readonly PropertyFetcher beforeActionAttributeRouteInfoFetcher = new("AttributeRouteInfo"); + private readonly PropertyFetcher beforeActionTemplateFetcher = new("Template"); +#endif + private readonly PropertyFetcher stopExceptionFetcher = new("Exception"); + private readonly AspNetCoreInstrumentationOptions options; + private readonly bool emitOldAttributes; + private readonly bool emitNewAttributes; + + public HttpInListener(AspNetCoreInstrumentationOptions options) + : base(DiagnosticSourceName) + { + Guard.ThrowIfNull(options); + + this.options = options; + + this.emitOldAttributes = this.options.HttpSemanticConvention.HasFlag(HttpSemanticConvention.Old); + + this.emitNewAttributes = this.options.HttpSemanticConvention.HasFlag(HttpSemanticConvention.New); + } + + public override void OnEventWritten(string name, object payload) + { + switch (name) + { + case OnStartEvent: + { + this.OnStartActivity(Activity.Current, payload); + } + + break; + case OnStopEvent: + { + this.OnStopActivity(Activity.Current, payload); + } + + break; + case OnMvcBeforeActionEvent: + { + this.OnMvcBeforeAction(Activity.Current, payload); + } + + break; + case OnUnhandledHostingExceptionEvent: + case OnUnHandledDiagnosticsExceptionEvent: + { + this.OnException(Activity.Current, payload); + } + + break; + } + } + + public void OnStartActivity(Activity activity, object payload) + { + // The overall flow of what AspNetCore library does is as below: + // Activity.Start() + // DiagnosticSource.WriteEvent("Start", payload) + // DiagnosticSource.WriteEvent("Stop", payload) + // Activity.Stop() + + // This method is in the WriteEvent("Start", payload) path. + // By this time, samplers have already run and + // activity.IsAllDataRequested populated accordingly. + + if (Sdk.SuppressInstrumentation) + { + return; + } + + HttpContext context = payload as HttpContext; + if (context == null) + { + AspNetCoreInstrumentationEventSource.Log.NullPayload(nameof(HttpInListener), nameof(this.OnStartActivity), activity.OperationName); + return; + } + + // Ensure context extraction irrespective of sampling decision + var request = context.Request; + var textMapPropagator = Propagators.DefaultTextMapPropagator; + if (textMapPropagator is not TraceContextPropagator) + { + var ctx = textMapPropagator.Extract(default, request, HttpRequestHeaderValuesGetter); + + if (ctx.ActivityContext.IsValid() + && ctx.ActivityContext != new ActivityContext(activity.TraceId, activity.ParentSpanId, activity.ActivityTraceFlags, activity.TraceStateString, true)) + { + // Create a new activity with its parent set from the extracted context. + // This makes the new activity as a "sibling" of the activity created by + // Asp.Net Core. +#if NET7_0_OR_GREATER + // For NET7.0 onwards activity is created using ActivitySource so, + // we will use the source of the activity to create the new one. + Activity newOne = activity.Source.CreateActivity(ActivityOperationName, ActivityKind.Server, ctx.ActivityContext); +#else + Activity newOne = new Activity(ActivityOperationName); + newOne.SetParentId(ctx.ActivityContext.TraceId, ctx.ActivityContext.SpanId, ctx.ActivityContext.TraceFlags); +#endif + newOne.TraceStateString = ctx.ActivityContext.TraceState; + + newOne.SetTag("IsCreatedByInstrumentation", bool.TrueString); + + // Starting the new activity make it the Activity.Current one. + newOne.Start(); + + // Set IsAllDataRequested to false for the activity created by the framework to only export the sibling activity and not the framework activity + activity.IsAllDataRequested = false; + activity = newOne; + } + + Baggage.Current = ctx.Baggage; + } + + // enrich Activity from payload only if sampling decision + // is favorable. + if (activity.IsAllDataRequested) + { + try + { + if (this.options.Filter?.Invoke(context) == false) + { + AspNetCoreInstrumentationEventSource.Log.RequestIsFilteredOut(nameof(HttpInListener), nameof(this.OnStartActivity), activity.OperationName); + activity.IsAllDataRequested = false; + activity.ActivityTraceFlags &= ~ActivityTraceFlags.Recorded; + return; + } + } + catch (Exception ex) + { + AspNetCoreInstrumentationEventSource.Log.RequestFilterException(nameof(HttpInListener), nameof(this.OnStartActivity), activity.OperationName, ex); + activity.IsAllDataRequested = false; + activity.ActivityTraceFlags &= ~ActivityTraceFlags.Recorded; + return; + } + +#if !NET7_0_OR_GREATER + ActivityInstrumentationHelper.SetActivitySourceProperty(activity, ActivitySource); + ActivityInstrumentationHelper.SetKindProperty(activity, ActivityKind.Server); +#endif + + var path = (request.PathBase.HasValue || request.Path.HasValue) ? (request.PathBase + request.Path).ToString() : "/"; + activity.DisplayName = path; + + // see the spec https://github.com/open-telemetry/opentelemetry-specification/blob/v1.20.0/specification/trace/semantic_conventions/http.md + if (this.emitOldAttributes) + { + if (request.Host.HasValue) + { + activity.SetTag(SemanticConventions.AttributeNetHostName, request.Host.Host); + + if (request.Host.Port is not null && request.Host.Port != 80 && request.Host.Port != 443) + { + activity.SetTag(SemanticConventions.AttributeNetHostPort, request.Host.Port); + } + } + + activity.SetTag(SemanticConventions.AttributeHttpMethod, request.Method); + activity.SetTag(SemanticConventions.AttributeHttpScheme, request.Scheme); + activity.SetTag(SemanticConventions.AttributeHttpTarget, path); + activity.SetTag(SemanticConventions.AttributeHttpUrl, GetUri(request)); + activity.SetTag(SemanticConventions.AttributeHttpFlavor, HttpTagHelper.GetFlavorTagValueFromProtocol(request.Protocol)); + + if (request.Headers.TryGetValue("User-Agent", out var values)) + { + var userAgent = values.Count > 0 ? values[0] : null; + if (!string.IsNullOrEmpty(userAgent)) + { + activity.SetTag(SemanticConventions.AttributeHttpUserAgent, userAgent); + } + } + } + + // see the spec https://github.com/open-telemetry/semantic-conventions/blob/v1.21.0/docs/http/http-spans.md + if (this.emitNewAttributes) + { + if (request.Host.HasValue) + { + activity.SetTag(SemanticConventions.AttributeServerAddress, request.Host.Host); + + if (request.Host.Port is not null && request.Host.Port != 80 && request.Host.Port != 443) + { + activity.SetTag(SemanticConventions.AttributeServerPort, request.Host.Port); + } + } + + if (request.QueryString.HasValue) + { + // QueryString should be sanitized. see: https://github.com/open-telemetry/opentelemetry-dotnet/issues/4571 + activity.SetTag(SemanticConventions.AttributeUrlQuery, request.QueryString.Value); + } + + activity.SetTag(SemanticConventions.AttributeHttpRequestMethod, request.Method); + activity.SetTag(SemanticConventions.AttributeUrlScheme, request.Scheme); + activity.SetTag(SemanticConventions.AttributeUrlPath, path); + activity.SetTag(SemanticConventions.AttributeNetworkProtocolVersion, HttpTagHelper.GetFlavorTagValueFromProtocol(request.Protocol)); + + if (request.Headers.TryGetValue("User-Agent", out var values)) + { + var userAgent = values.Count > 0 ? values[0] : null; + if (!string.IsNullOrEmpty(userAgent)) + { + activity.SetTag(SemanticConventions.AttributeUserAgentOriginal, userAgent); + } + } + } + + try + { + this.options.EnrichWithHttpRequest?.Invoke(activity, request); + } + catch (Exception ex) + { + AspNetCoreInstrumentationEventSource.Log.EnrichmentException(nameof(HttpInListener), nameof(this.OnStartActivity), activity.OperationName, ex); + } + } + } + + public void OnStopActivity(Activity activity, object payload) + { + if (activity.IsAllDataRequested) + { + HttpContext context = payload as HttpContext; + if (context == null) + { + AspNetCoreInstrumentationEventSource.Log.NullPayload(nameof(HttpInListener), nameof(this.OnStopActivity), activity.OperationName); + return; + } + + var response = context.Response; + + if (this.emitOldAttributes) + { + activity.SetTag(SemanticConventions.AttributeHttpStatusCode, TelemetryHelper.GetBoxedStatusCode(response.StatusCode)); + } + + if (this.emitNewAttributes) + { + activity.SetTag(SemanticConventions.AttributeHttpResponseStatusCode, TelemetryHelper.GetBoxedStatusCode(response.StatusCode)); + } + +#if !NETSTANDARD2_0 + if (this.options.EnableGrpcAspNetCoreSupport && TryGetGrpcMethod(activity, out var grpcMethod)) + { + this.AddGrpcAttributes(activity, grpcMethod, context); + } + else if (activity.Status == ActivityStatusCode.Unset) + { + activity.SetStatus(SpanHelper.ResolveSpanStatusForHttpStatusCode(activity.Kind, response.StatusCode)); + } +#else + if (activity.Status == ActivityStatusCode.Unset) + { + activity.SetStatus(SpanHelper.ResolveSpanStatusForHttpStatusCode(activity.Kind, response.StatusCode)); + } +#endif + + try + { + this.options.EnrichWithHttpResponse?.Invoke(activity, response); + } + catch (Exception ex) + { + AspNetCoreInstrumentationEventSource.Log.EnrichmentException(nameof(HttpInListener), nameof(this.OnStopActivity), activity.OperationName, ex); + } + } + +#if NET7_0_OR_GREATER + var tagValue = activity.GetTagValue("IsCreatedByInstrumentation"); + if (ReferenceEquals(tagValue, bool.TrueString)) +#else + if (activity.TryCheckFirstTag("IsCreatedByInstrumentation", out var tagValue) && ReferenceEquals(tagValue, bool.TrueString)) +#endif + { + // If instrumentation started a new Activity, it must + // be stopped here. + activity.SetTag("IsCreatedByInstrumentation", null); + activity.Stop(); + + // After the activity.Stop() code, Activity.Current becomes null. + // If Asp.Net Core uses Activity.Current?.Stop() - it'll not stop the activity + // it created. + // Currently Asp.Net core does not use Activity.Current, instead it stores a + // reference to its activity, and calls .Stop on it. + + // TODO: Should we still restore Activity.Current here? + // If yes, then we need to store the asp.net core activity inside + // the one created by the instrumentation. + // And retrieve it here, and set it to Current. + } + } + + public void OnMvcBeforeAction(Activity activity, object payload) + { + // We cannot rely on Activity.Current here + // There could be activities started by middleware + // after activity started by framework resulting in different Activity.Current. + // so, we need to first find the activity started by Asp.Net Core. + // For .net6.0 onwards we could use IHttpActivityFeature to get the activity created by framework + // var httpActivityFeature = context.Features.Get(); + // activity = httpActivityFeature.Activity; + // However, this will not work as in case of custom propagator + // we start a new activity during onStart event which is a sibling to the activity created by framework + // So, in that case we need to get the activity created by us here. + // we can do so only by looping through activity.Parent chain. + while (activity != null) + { + if (string.Equals(activity.OperationName, ActivityOperationName, StringComparison.Ordinal)) + { + break; + } + + activity = activity.Parent; + } + + if (activity == null) + { + return; + } + + if (activity.IsAllDataRequested) + { +#if !NET6_0_OR_GREATER + _ = this.beforeActionActionDescriptorFetcher.TryFetch(payload, out var actionDescriptor); + _ = this.beforeActionAttributeRouteInfoFetcher.TryFetch(actionDescriptor, out var attributeRouteInfo); + _ = this.beforeActionTemplateFetcher.TryFetch(attributeRouteInfo, out var template); +#else + var beforeActionEventData = payload as BeforeActionEventData; + var template = beforeActionEventData.ActionDescriptor?.AttributeRouteInfo?.Template; +#endif + if (!string.IsNullOrEmpty(template)) + { + // override the span name that was previously set to the path part of URL. + activity.DisplayName = template; + activity.SetTag(SemanticConventions.AttributeHttpRoute, template); + } + + // TODO: Should we get values from RouteData? + // private readonly PropertyFetcher beforeActionRouteDataFetcher = new PropertyFetcher("routeData"); + // var routeData = this.beforeActionRouteDataFetcher.Fetch(payload) as RouteData; + } + } + + public void OnException(Activity activity, object payload) + { + if (activity.IsAllDataRequested) + { + // We need to use reflection here as the payload type is not a defined public type. + if (!this.stopExceptionFetcher.TryFetch(payload, out Exception exc) || exc == null) + { + AspNetCoreInstrumentationEventSource.Log.NullPayload(nameof(HttpInListener), nameof(this.OnException), activity.OperationName); + return; + } + + if (this.options.RecordException) + { + activity.RecordException(exc); + } + + activity.SetStatus(ActivityStatusCode.Error, exc.Message); + + try + { + this.options.EnrichWithException?.Invoke(activity, exc); + } + catch (Exception ex) + { + AspNetCoreInstrumentationEventSource.Log.EnrichmentException(nameof(HttpInListener), nameof(this.OnException), activity.OperationName, ex); + } + } + } + + private static string GetUri(HttpRequest request) + { + // this follows the suggestions from https://github.com/dotnet/aspnetcore/issues/28906 + var scheme = request.Scheme ?? string.Empty; + + // HTTP 1.0 request with NO host header would result in empty Host. + // Use placeholder to avoid incorrect URL like "http:///" + var host = request.Host.Value ?? UnknownHostName; + var pathBase = request.PathBase.Value ?? string.Empty; + var path = request.Path.Value ?? string.Empty; + var queryString = request.QueryString.Value ?? string.Empty; + var length = scheme.Length + Uri.SchemeDelimiter.Length + host.Length + pathBase.Length + + path.Length + queryString.Length; + +#if NETSTANDARD2_1_OR_GREATER || NET6_0_OR_GREATER + return string.Create(length, (scheme, host, pathBase, path, queryString), (span, parts) => + { + CopyTo(ref span, parts.scheme); + CopyTo(ref span, Uri.SchemeDelimiter); + CopyTo(ref span, parts.host); + CopyTo(ref span, parts.pathBase); + CopyTo(ref span, parts.path); + CopyTo(ref span, parts.queryString); + + static void CopyTo(ref Span buffer, ReadOnlySpan text) + { + if (!text.IsEmpty) + { + text.CopyTo(buffer); + buffer = buffer.Slice(text.Length); + } + } + }); +#else + return new System.Text.StringBuilder(length) + .Append(scheme) + .Append(Uri.SchemeDelimiter) + .Append(host) + .Append(pathBase) + .Append(path) + .Append(queryString) + .ToString(); +#endif + } + +#if !NETSTANDARD2_0 + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static bool TryGetGrpcMethod(Activity activity, out string grpcMethod) + { + grpcMethod = GrpcTagHelper.GetGrpcMethodFromActivity(activity); + return !string.IsNullOrEmpty(grpcMethod); + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private void AddGrpcAttributes(Activity activity, string grpcMethod, HttpContext context) + { + // The RPC semantic conventions indicate the span name + // should not have a leading forward slash. + // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/semantic_conventions/rpc.md#span-name + activity.DisplayName = grpcMethod.TrimStart('/'); + + activity.SetTag(SemanticConventions.AttributeRpcSystem, GrpcTagHelper.RpcSystemGrpc); + + if (this.emitOldAttributes) + { + if (context.Connection.RemoteIpAddress != null) + { + // TODO: This attribute was changed in v1.13.0 https://github.com/open-telemetry/opentelemetry-specification/pull/2614 + activity.SetTag(SemanticConventions.AttributeNetPeerIp, context.Connection.RemoteIpAddress.ToString()); + } + + activity.SetTag(SemanticConventions.AttributeNetPeerPort, context.Connection.RemotePort); + } + + // see the spec https://github.com/open-telemetry/semantic-conventions/blob/v1.21.0/docs/rpc/rpc-spans.md + if (this.emitNewAttributes) + { + if (context.Connection.RemoteIpAddress != null) + { + activity.SetTag(SemanticConventions.AttributeClientAddress, context.Connection.RemoteIpAddress.ToString()); + } + + activity.SetTag(SemanticConventions.AttributeClientPort, context.Connection.RemotePort); + } + + bool validConversion = GrpcTagHelper.TryGetGrpcStatusCodeFromActivity(activity, out int status); + if (validConversion) + { + activity.SetStatus(GrpcTagHelper.ResolveSpanStatusForGrpcStatusCode(status)); + } + + if (GrpcTagHelper.TryParseRpcServiceAndRpcMethod(grpcMethod, out var rpcService, out var rpcMethod)) + { + activity.SetTag(SemanticConventions.AttributeRpcService, rpcService); + activity.SetTag(SemanticConventions.AttributeRpcMethod, rpcMethod); + + // Remove the grpc.method tag added by the gRPC .NET library + activity.SetTag(GrpcTagHelper.GrpcMethodTagName, null); + + // Remove the grpc.status_code tag added by the gRPC .NET library + activity.SetTag(GrpcTagHelper.GrpcStatusCodeTagName, null); + + if (validConversion) + { + // setting rpc.grpc.status_code + activity.SetTag(SemanticConventions.AttributeRpcGrpcStatusCode, status); + } + } + } +#endif + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/Implementation/HttpInMetricsListener.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/Implementation/HttpInMetricsListener.cs new file mode 100644 index 000000000000..4d31267415b7 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/Implementation/HttpInMetricsListener.cs @@ -0,0 +1,153 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Diagnostics.Metrics; +using Microsoft.AspNetCore.Http; +#if NET6_0_OR_GREATER +using Microsoft.AspNetCore.Routing; +#endif +using OpenTelemetry.Trace; +using static OpenTelemetry.Internal.HttpSemanticConventionHelper; + +namespace OpenTelemetry.Instrumentation.AspNetCore.Implementation +{ + internal sealed class HttpInMetricsListener : ListenerHandler + { + private const string HttpServerDurationMetricName = "http.server.duration"; + private const string OnStopEvent = "Microsoft.AspNetCore.Hosting.HttpRequestIn.Stop"; + private const string EventName = "OnStopActivity"; + + private readonly Meter meter; + private readonly AspNetCoreMetricsInstrumentationOptions options; + private readonly Histogram httpServerDuration; + private readonly bool emitOldAttributes; + private readonly bool emitNewAttributes; + + internal HttpInMetricsListener(string name, Meter meter, AspNetCoreMetricsInstrumentationOptions options) + : base(name) + { + this.meter = meter; + this.options = options; + this.httpServerDuration = meter.CreateHistogram(HttpServerDurationMetricName, "ms", "Measures the duration of inbound HTTP requests."); + + this.emitOldAttributes = this.options.HttpSemanticConvention.HasFlag(HttpSemanticConvention.Old); + + this.emitNewAttributes = this.options.HttpSemanticConvention.HasFlag(HttpSemanticConvention.New); + } + + public override void OnEventWritten(string name, object payload) + { + if (name == OnStopEvent) + { + var context = payload as HttpContext; + if (context == null) + { + AspNetCoreInstrumentationEventSource.Log.NullPayload(nameof(HttpInMetricsListener), EventName, HttpServerDurationMetricName); + return; + } + + try + { + if (this.options.Filter?.Invoke(HttpServerDurationMetricName, context) == false) + { + AspNetCoreInstrumentationEventSource.Log.RequestIsFilteredOut(nameof(HttpInMetricsListener), EventName, HttpServerDurationMetricName); + return; + } + } + catch (Exception ex) + { + AspNetCoreInstrumentationEventSource.Log.RequestFilterException(nameof(HttpInMetricsListener), EventName, HttpServerDurationMetricName, ex); + return; + } + + // TODO: Prometheus pulls metrics by invoking the /metrics endpoint. Decide if it makes sense to suppress this. + // Below is just a temporary way of achieving this suppression for metrics (we should consider suppressing traces too). + // If we want to suppress activity from Prometheus then we should use SuppressInstrumentationScope. + if (context.Request.Path.HasValue && context.Request.Path.Value.Contains("metrics")) + { + return; + } + + TagList tags = default; + + // see the spec https://github.com/open-telemetry/opentelemetry-specification/blob/v1.20.0/specification/trace/semantic_conventions/http.md + if (this.emitOldAttributes) + { + tags.Add(new KeyValuePair(SemanticConventions.AttributeHttpFlavor, HttpTagHelper.GetFlavorTagValueFromProtocol(context.Request.Protocol))); + tags.Add(new KeyValuePair(SemanticConventions.AttributeHttpScheme, context.Request.Scheme)); + tags.Add(new KeyValuePair(SemanticConventions.AttributeHttpMethod, context.Request.Method)); + tags.Add(new KeyValuePair(SemanticConventions.AttributeHttpStatusCode, TelemetryHelper.GetBoxedStatusCode(context.Response.StatusCode))); + + if (context.Request.Host.HasValue) + { + tags.Add(new KeyValuePair(SemanticConventions.AttributeNetHostName, context.Request.Host.Host)); + + if (context.Request.Host.Port is not null && context.Request.Host.Port != 80 && context.Request.Host.Port != 443) + { + tags.Add(new KeyValuePair(SemanticConventions.AttributeNetHostPort, context.Request.Host.Port)); + } + } + } + + // see the spec https://github.com/open-telemetry/semantic-conventions/blob/v1.21.0/docs/http/http-spans.md + if (this.emitNewAttributes) + { + tags.Add(new KeyValuePair(SemanticConventions.AttributeNetworkProtocolVersion, HttpTagHelper.GetFlavorTagValueFromProtocol(context.Request.Protocol))); + tags.Add(new KeyValuePair(SemanticConventions.AttributeUrlScheme, context.Request.Scheme)); + tags.Add(new KeyValuePair(SemanticConventions.AttributeHttpRequestMethod, context.Request.Method)); + tags.Add(new KeyValuePair(SemanticConventions.AttributeHttpResponseStatusCode, TelemetryHelper.GetBoxedStatusCode(context.Response.StatusCode))); + + if (context.Request.Host.HasValue) + { + tags.Add(new KeyValuePair(SemanticConventions.AttributeServerAddress, context.Request.Host.Host)); + + if (context.Request.Host.Port is not null && context.Request.Host.Port != 80 && context.Request.Host.Port != 443) + { + tags.Add(new KeyValuePair(SemanticConventions.AttributeServerPort, context.Request.Host.Port)); + } + } + } + +#if NET6_0_OR_GREATER + var route = (context.GetEndpoint() as RouteEndpoint)?.RoutePattern.RawText; + if (!string.IsNullOrEmpty(route)) + { + tags.Add(new KeyValuePair(SemanticConventions.AttributeHttpRoute, route)); + } +#endif + if (this.options.Enrich != null) + { + try + { + this.options.Enrich(HttpServerDurationMetricName, context, ref tags); + } + catch (Exception ex) + { + AspNetCoreInstrumentationEventSource.Log.EnrichmentException(nameof(HttpInMetricsListener), EventName, HttpServerDurationMetricName, ex); + } + } + + // We are relying here on ASP.NET Core to set duration before writing the stop event. + // https://github.com/dotnet/aspnetcore/blob/d6fa351048617ae1c8b47493ba1abbe94c3a24cf/src/Hosting/Hosting/src/Internal/HostingApplicationDiagnostics.cs#L449 + // TODO: Follow up with .NET team if we can continue to rely on this behavior. + this.httpServerDuration.Record(Activity.Current.Duration.TotalMilliseconds, tags); + } + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/Implementation/HttpTagHelper.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/Implementation/HttpTagHelper.cs new file mode 100644 index 000000000000..73114efe0b30 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/Implementation/HttpTagHelper.cs @@ -0,0 +1,47 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +namespace OpenTelemetry.Instrumentation.AspNetCore.Implementation +{ + /// + /// A collection of helper methods to be used when building Http activities. + /// + internal static class HttpTagHelper + { + /// + /// Gets the OpenTelemetry standard version tag value for a span based on its protocol/>. + /// + /// . + /// Span flavor value. + public static string GetFlavorTagValueFromProtocol(string protocol) + { + switch (protocol) + { + case "HTTP/2": + return "2.0"; + + case "HTTP/3": + return "3.0"; + + case "HTTP/1.1": + return "1.1"; + + default: + return protocol; + } + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/Implementation/TelemetryHelper.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/Implementation/TelemetryHelper.cs new file mode 100644 index 000000000000..73d84269e829 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/Implementation/TelemetryHelper.cs @@ -0,0 +1,41 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +namespace OpenTelemetry.Instrumentation.AspNetCore.Implementation; + +internal static class TelemetryHelper +{ + public static readonly object[] BoxedStatusCodes; + + static TelemetryHelper() + { + BoxedStatusCodes = new object[500]; + for (int i = 0, c = 100; i < BoxedStatusCodes.Length; i++, c++) + { + BoxedStatusCodes[i] = c; + } + } + + public static object GetBoxedStatusCode(int statusCode) + { + if (statusCode >= 100 && statusCode < 600) + { + return BoxedStatusCodes[statusCode - 100]; + } + + return statusCode; + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/MeterProviderBuilderExtensions.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/MeterProviderBuilderExtensions.cs new file mode 100644 index 000000000000..d0238570e3da --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/MeterProviderBuilderExtensions.cs @@ -0,0 +1,96 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Options; +using OpenTelemetry.Instrumentation.AspNetCore; +using OpenTelemetry.Instrumentation.AspNetCore.Implementation; +using OpenTelemetry.Internal; + +namespace OpenTelemetry.Metrics +{ + /// + /// Extension methods to simplify registering of ASP.NET Core request instrumentation. + /// + internal static class MeterProviderBuilderExtensions + { + /// + /// Enables the incoming requests automatic data collection for ASP.NET Core. + /// + /// being configured. + /// The instance of to chain the calls. + public static MeterProviderBuilder AddAspNetCoreInstrumentation( + this MeterProviderBuilder builder) + => AddAspNetCoreInstrumentation(builder, name: null, configureAspNetCoreInstrumentationOptions: null); + + /// + /// Enables the incoming requests automatic data collection for ASP.NET Core. + /// + /// being configured. + /// Callback action for configuring . + /// The instance of to chain the calls. + public static MeterProviderBuilder AddAspNetCoreInstrumentation( + this MeterProviderBuilder builder, + Action configureAspNetCoreInstrumentationOptions) + => AddAspNetCoreInstrumentation(builder, name: null, configureAspNetCoreInstrumentationOptions); + + /// + /// Enables the incoming requests automatic data collection for ASP.NET Core. + /// + /// being configured. + /// Name which is used when retrieving options. + /// Callback action for configuring . + /// The instance of to chain the calls. + public static MeterProviderBuilder AddAspNetCoreInstrumentation( + this MeterProviderBuilder builder, + string name, + Action configureAspNetCoreInstrumentationOptions) + { + Guard.ThrowIfNull(builder); + + // Note: Warm-up the status code mapping. + _ = TelemetryHelper.BoxedStatusCodes; + + name ??= Options.DefaultName; + + builder.ConfigureServices(services => + { + if (configureAspNetCoreInstrumentationOptions != null) + { + services.Configure(name, configureAspNetCoreInstrumentationOptions); + } + + services.RegisterOptionsFactory(configuration => new AspNetCoreMetricsInstrumentationOptions(configuration)); + }); + + builder.AddMeter(AspNetCoreMetrics.InstrumentationName); + + builder.AddInstrumentation(sp => + { + var options = sp.GetRequiredService>().Get(name); + + // TODO: Add additional options to AspNetCoreMetricsInstrumentationOptions ? + // RecordException - probably doesn't make sense for metric instrumentation + // EnableGrpcAspNetCoreSupport - this instrumentation will also need to also handle gRPC requests + + return new AspNetCoreMetrics(options); + }); + + return builder; + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/TracerProviderBuilderExtensions.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/TracerProviderBuilderExtensions.cs new file mode 100644 index 000000000000..dfd9a8076ddb --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.AspNetCore/TracerProviderBuilderExtensions.cs @@ -0,0 +1,136 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#if NET7_0_OR_GREATER +using System.Diagnostics; +#endif +using System; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Options; +using OpenTelemetry.Instrumentation.AspNetCore; +using OpenTelemetry.Instrumentation.AspNetCore.Implementation; +using OpenTelemetry.Internal; + +namespace OpenTelemetry.Trace +{ + /// + /// Extension methods to simplify registering of ASP.NET Core request instrumentation. + /// + internal static class TracerProviderBuilderExtensions + { + /// + /// Enables the incoming requests automatic data collection for ASP.NET Core. + /// + /// being configured. + /// The instance of to chain the calls. + public static TracerProviderBuilder AddAspNetCoreInstrumentation(this TracerProviderBuilder builder) + => AddAspNetCoreInstrumentation(builder, name: null, configureAspNetCoreInstrumentationOptions: null); + + /// + /// Enables the incoming requests automatic data collection for ASP.NET Core. + /// + /// being configured. + /// Callback action for configuring . + /// The instance of to chain the calls. + public static TracerProviderBuilder AddAspNetCoreInstrumentation( + this TracerProviderBuilder builder, + Action configureAspNetCoreInstrumentationOptions) + => AddAspNetCoreInstrumentation(builder, name: null, configureAspNetCoreInstrumentationOptions); + + /// + /// Enables the incoming requests automatic data collection for ASP.NET Core. + /// + /// being configured. + /// Name which is used when retrieving options. + /// Callback action for configuring . + /// The instance of to chain the calls. + public static TracerProviderBuilder AddAspNetCoreInstrumentation( + this TracerProviderBuilder builder, + string name, + Action configureAspNetCoreInstrumentationOptions) + { + Guard.ThrowIfNull(builder); + + // Note: Warm-up the status code mapping. + _ = TelemetryHelper.BoxedStatusCodes; + + name ??= Options.DefaultName; + + builder.ConfigureServices(services => + { + if (configureAspNetCoreInstrumentationOptions != null) + { + services.Configure(name, configureAspNetCoreInstrumentationOptions); + } + + services.RegisterOptionsFactory(configuration => new AspNetCoreInstrumentationOptions(configuration)); + }); + + if (builder is IDeferredTracerProviderBuilder deferredTracerProviderBuilder) + { + deferredTracerProviderBuilder.Configure((sp, builder) => + { + AddAspNetCoreInstrumentationSources(builder, sp); + }); + } + + return builder.AddInstrumentation(sp => + { + var options = sp.GetRequiredService>().Get(name); + + return new AspNetCoreInstrumentation( + new HttpInListener(options)); + }); + } + + // Note: This is used by unit tests. + internal static TracerProviderBuilder AddAspNetCoreInstrumentation( + this TracerProviderBuilder builder, + HttpInListener listener) + { + builder.AddAspNetCoreInstrumentationSources(); + + return builder.AddInstrumentation( + new AspNetCoreInstrumentation(listener)); + } + + private static void AddAspNetCoreInstrumentationSources( + this TracerProviderBuilder builder, + IServiceProvider serviceProvider = null) + { + // For .NET7.0 onwards activity will be created using activitySource. + // https://github.com/dotnet/aspnetcore/blob/bf3352f2422bf16fa3ca49021f0e31961ce525eb/src/Hosting/Hosting/src/Internal/HostingApplicationDiagnostics.cs#L327 + // For .NET6.0 and below, we will continue to use legacy way. +#if NET7_0_OR_GREATER + // TODO: Check with .NET team to see if this can be prevented + // as this allows user to override the ActivitySource. + var activitySourceService = serviceProvider?.GetService(); + if (activitySourceService != null) + { + builder.AddSource(activitySourceService.Name); + } + else + { + // For users not using hosting package? + builder.AddSource(HttpInListener.AspNetCoreActivitySourceName); + } +#else + builder.AddSource(HttpInListener.ActivitySourceName); + builder.AddLegacySource(HttpInListener.ActivityOperationName); // for the activities created by AspNetCore +#endif + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/HttpClientInstrumentation.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/HttpClientInstrumentation.cs new file mode 100644 index 000000000000..d0050c4cf89f --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/HttpClientInstrumentation.cs @@ -0,0 +1,78 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +using System; +using System.Collections.Generic; +using OpenTelemetry.Instrumentation.Http.Implementation; + +namespace OpenTelemetry.Instrumentation.Http +{ + /// + /// HttpClient instrumentation. + /// + internal sealed class HttpClientInstrumentation : IDisposable + { + private static readonly HashSet ExcludedDiagnosticSourceEventsNet7OrGreater = new() + { + "System.Net.Http.Request", + "System.Net.Http.Response", + "System.Net.Http.HttpRequestOut", + }; + + private static readonly HashSet ExcludedDiagnosticSourceEvents = new() + { + "System.Net.Http.Request", + "System.Net.Http.Response", + }; + + private readonly DiagnosticSourceSubscriber diagnosticSourceSubscriber; + + private readonly Func isEnabled = (eventName, _, _) + => !ExcludedDiagnosticSourceEvents.Contains(eventName); + + private readonly Func isEnabledNet7OrGreater = (eventName, _, _) + => !ExcludedDiagnosticSourceEventsNet7OrGreater.Contains(eventName); + + /// + /// Initializes a new instance of the class. + /// + /// Configuration options for HTTP client instrumentation. + public HttpClientInstrumentation(HttpClientInstrumentationOptions options) + { + // For .NET7.0 activity will be created using activitySource. + // https://github.com/dotnet/runtime/blob/main/src/libraries/System.Net.Http/src/System/Net/Http/DiagnosticsHandler.cs + // However, in case when activity creation returns null (due to sampling) + // the framework will fall back to creating activity anyways due to active diagnostic source listener + // To prevent this, isEnabled is implemented which will return false always + // so that the sampler's decision is respected. + if (HttpHandlerDiagnosticListener.IsNet7OrGreater) + { + this.diagnosticSourceSubscriber = new DiagnosticSourceSubscriber(new HttpHandlerDiagnosticListener(options), this.isEnabledNet7OrGreater); + } + else + { + this.diagnosticSourceSubscriber = new DiagnosticSourceSubscriber(new HttpHandlerDiagnosticListener(options), this.isEnabled); + } + + this.diagnosticSourceSubscriber.Subscribe(); + } + + /// + public void Dispose() + { + this.diagnosticSourceSubscriber?.Dispose(); + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/HttpClientInstrumentationOptions.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/HttpClientInstrumentationOptions.cs new file mode 100644 index 000000000000..9917229a0298 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/HttpClientInstrumentationOptions.cs @@ -0,0 +1,198 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using System.Diagnostics; +using System.Net; +using System.Net.Http; +#if NETFRAMEWORK +using System.Net.Http; +#endif +using System.Runtime.CompilerServices; +using Microsoft.Extensions.Configuration; +using OpenTelemetry.Instrumentation.Http.Implementation; +using static OpenTelemetry.Internal.HttpSemanticConventionHelper; + +namespace OpenTelemetry.Instrumentation.Http +{ + /// + /// Options for HttpClient instrumentation. + /// + internal class HttpClientInstrumentationOptions + { + internal readonly HttpSemanticConvention HttpSemanticConvention; + + /// + /// Initializes a new instance of the class. + /// + public HttpClientInstrumentationOptions() + : this(new ConfigurationBuilder().AddEnvironmentVariables().Build()) + { + } + + internal HttpClientInstrumentationOptions(IConfiguration configuration) + { + Debug.Assert(configuration != null, "configuration was null"); + + this.HttpSemanticConvention = GetSemanticConventionOptIn(configuration); + } + + /// + /// Gets or sets a filter function that determines whether or not to + /// collect telemetry on a per request basis. + /// + /// + /// FilterHttpRequestMessage is only executed on .NET and .NET + /// Core runtimes. and on .NET and .NET Core are both implemented + /// using . + /// Notes: + /// + /// The return value for the filter function is interpreted as: + /// + /// If filter returns , the request is + /// collected. + /// If filter returns or throws an + /// exception the request is NOT collected. + /// + /// + /// + public Func FilterHttpRequestMessage { get; set; } + + /// + /// Gets or sets an action to enrich an with . + /// + /// + /// EnrichWithHttpRequestMessage is only executed on .NET and .NET + /// Core runtimes. and on .NET and .NET Core are both implemented + /// using . + /// + public Action EnrichWithHttpRequestMessage { get; set; } + + /// + /// Gets or sets an action to enrich an with . + /// + /// + /// EnrichWithHttpResponseMessage is only executed on .NET and .NET + /// Core runtimes. and on .NET and .NET Core are both implemented + /// using . + /// + public Action EnrichWithHttpResponseMessage { get; set; } + + /// + /// Gets or sets an action to enrich an with . + /// + /// + /// EnrichWithException is called for all runtimes. + /// + public Action EnrichWithException { get; set; } + + /// + /// Gets or sets a filter function that determines whether or not to + /// collect telemetry on a per request basis. + /// + /// + /// FilterHttpWebRequest is only executed on .NET Framework + /// runtimes. and + /// on .NET Framework are both implemented using . + /// Notes: + /// + /// The return value for the filter function is interpreted as: + /// + /// If filter returns , the request is + /// collected. + /// If filter returns or throws an + /// exception the request is NOT collected. + /// + /// + /// + public Func FilterHttpWebRequest { get; set; } + + /// + /// Gets or sets an action to enrich an with . + /// + /// + /// EnrichWithHttpWebRequest is only executed on .NET Framework + /// runtimes. and + /// on .NET Framework are both implemented using . + /// + public Action EnrichWithHttpWebRequest { get; set; } + + /// + /// Gets or sets an action to enrich an with . + /// + /// + /// EnrichWithHttpWebResponse is only executed on .NET Framework + /// runtimes. and + /// on .NET Framework are both implemented using . + /// + public Action EnrichWithHttpWebResponse { get; set; } + + /// + /// Gets or sets a value indicating whether exception will be recorded + /// as an or not. Default value: . + /// + /// + /// RecordException is supported on all runtimes. + /// For specification details see: . + /// + public bool RecordException { get; set; } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal bool EventFilterHttpRequestMessage(string activityName, object arg1) + { + try + { + return + this.FilterHttpRequestMessage == null || + !TryParseHttpRequestMessage(activityName, arg1, out HttpRequestMessage requestMessage) || + this.FilterHttpRequestMessage(requestMessage); + } + catch (Exception ex) + { + HttpInstrumentationEventSource.Log.RequestFilterException(ex); + return false; + } + } + + internal bool EventFilterHttpWebRequest(HttpWebRequest request) + { + try + { + return this.FilterHttpWebRequest?.Invoke(request) ?? true; + } + catch (Exception ex) + { + HttpInstrumentationEventSource.Log.RequestFilterException(ex); + return false; + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static bool TryParseHttpRequestMessage(string activityName, object arg1, out HttpRequestMessage requestMessage) + { + return (requestMessage = arg1 as HttpRequestMessage) != null && activityName == "System.Net.Http.HttpRequestOut"; + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/HttpClientMetricInstrumentationOptions.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/HttpClientMetricInstrumentationOptions.cs new file mode 100644 index 000000000000..57ce8b3a6b20 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/HttpClientMetricInstrumentationOptions.cs @@ -0,0 +1,42 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System.Diagnostics; +using Microsoft.Extensions.Configuration; +using static OpenTelemetry.Internal.HttpSemanticConventionHelper; + +namespace OpenTelemetry.Instrumentation.Http +{ + internal sealed class HttpClientMetricInstrumentationOptions + { + internal readonly HttpSemanticConvention HttpSemanticConvention; + + /// + /// Initializes a new instance of the class. + /// + public HttpClientMetricInstrumentationOptions() + : this(new ConfigurationBuilder().AddEnvironmentVariables().Build()) + { + } + + internal HttpClientMetricInstrumentationOptions(IConfiguration configuration) + { + Debug.Assert(configuration != null, "configuration was null"); + + this.HttpSemanticConvention = GetSemanticConventionOptIn(configuration); + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/HttpClientMetrics.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/HttpClientMetrics.cs new file mode 100644 index 000000000000..f210a962155a --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/HttpClientMetrics.cs @@ -0,0 +1,64 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using System.Collections.Generic; +using System.Diagnostics.Metrics; +using System.Reflection; +using OpenTelemetry.Instrumentation.Http.Implementation; + +namespace OpenTelemetry.Instrumentation.Http +{ + /// + /// HttpClient instrumentation. + /// + internal sealed class HttpClientMetrics : IDisposable + { + internal static readonly AssemblyName AssemblyName = typeof(HttpClientMetrics).Assembly.GetName(); + internal static readonly string InstrumentationName = AssemblyName.Name; + internal static readonly string InstrumentationVersion = AssemblyName.Version.ToString(); + + private static readonly HashSet ExcludedDiagnosticSourceEvents = new() + { + "System.Net.Http.Request", + "System.Net.Http.Response", + }; + + private readonly DiagnosticSourceSubscriber diagnosticSourceSubscriber; + private readonly Meter meter; + + private readonly Func isEnabled = (activityName, obj1, obj2) + => !ExcludedDiagnosticSourceEvents.Contains(activityName); + + /// + /// Initializes a new instance of the class. + /// + /// HttpClient metric instrumentation options. + public HttpClientMetrics(HttpClientMetricInstrumentationOptions options) + { + this.meter = new Meter(InstrumentationName, InstrumentationVersion); + this.diagnosticSourceSubscriber = new DiagnosticSourceSubscriber(new HttpHandlerMetricsDiagnosticListener("HttpHandlerDiagnosticListener", this.meter, options), this.isEnabled); + this.diagnosticSourceSubscriber.Subscribe(); + } + + /// + public void Dispose() + { + this.diagnosticSourceSubscriber?.Dispose(); + this.meter?.Dispose(); + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/HttpClient_MeterProviderBuilderExtensions.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/HttpClient_MeterProviderBuilderExtensions.cs new file mode 100644 index 000000000000..bb8d7916d15a --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/HttpClient_MeterProviderBuilderExtensions.cs @@ -0,0 +1,61 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Options; +using OpenTelemetry.Instrumentation.Http; +using OpenTelemetry.Instrumentation.Http.Implementation; +using OpenTelemetry.Internal; + +namespace OpenTelemetry.Metrics +{ + /// + /// Extension methods to simplify registering of HttpClient instrumentation. + /// + internal static class HttpClient_MeterProviderBuilderExtensions + { + /// + /// Enables HttpClient instrumentation. + /// + /// being configured. + /// The instance of to chain the calls. + public static MeterProviderBuilder AddHttpClientInstrumentation( + this MeterProviderBuilder builder) + { + Guard.ThrowIfNull(builder); + + // Note: Warm-up the status code mapping. + _ = TelemetryHelper.BoxedStatusCodes; + + builder.ConfigureServices(services => + { + services.RegisterOptionsFactory(configuration => new HttpClientMetricInstrumentationOptions(configuration)); + }); + + // TODO: Implement an IDeferredMeterProviderBuilder + + // TODO: Handle HttpClientInstrumentationOptions + // SetHttpFlavor - seems like this would be handled by views + // Filter - makes sense for metric instrumentation + // Enrich - do we want a similar kind of functionality for metrics? + // RecordException - probably doesn't make sense for metric instrumentation + + builder.AddMeter(HttpClientMetrics.InstrumentationName); + return builder.AddInstrumentation(sp => new HttpClientMetrics( + sp.GetRequiredService>().CurrentValue)); + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/HttpClient_TracerProviderBuilderExtensions.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/HttpClient_TracerProviderBuilderExtensions.cs new file mode 100644 index 000000000000..e5b4214a0749 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/HttpClient_TracerProviderBuilderExtensions.cs @@ -0,0 +1,120 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Options; +using OpenTelemetry.Instrumentation.Http; +using OpenTelemetry.Instrumentation.Http.Implementation; +using OpenTelemetry.Internal; + +namespace OpenTelemetry.Trace +{ + /// + /// Extension methods to simplify registering of HttpClient instrumentation. + /// + internal static class HttpClient_TracerProviderBuilderExtensions + { + /// + /// Enables HttpClient instrumentation. + /// + /// being configured. + /// The instance of to chain the calls. + public static TracerProviderBuilder AddHttpClientInstrumentation(this TracerProviderBuilder builder) + => AddHttpClientInstrumentation(builder, name: null, configureHttpClientInstrumentationOptions: null); + + /// + /// Enables HttpClient instrumentation. + /// + /// being configured. + /// Callback action for configuring . + /// The instance of to chain the calls. + internal static TracerProviderBuilder AddHttpClientInstrumentation( + this TracerProviderBuilder builder, + Action configureHttpClientInstrumentationOptions) + => AddHttpClientInstrumentation(builder, name: null, configureHttpClientInstrumentationOptions); + + /// + /// Enables HttpClient instrumentation. + /// + /// being configured. + /// Name which is used when retrieving options. + /// Callback action for configuring . + /// The instance of to chain the calls. + internal static TracerProviderBuilder AddHttpClientInstrumentation( + this TracerProviderBuilder builder, + string name, + Action configureHttpClientInstrumentationOptions) + { + Guard.ThrowIfNull(builder); + + // Note: Warm-up the status code mapping. + _ = TelemetryHelper.BoxedStatusCodes; + + name ??= Options.DefaultName; + + builder.ConfigureServices(services => + { + if (configureHttpClientInstrumentationOptions != null) + { + services.Configure(name, configureHttpClientInstrumentationOptions); + } + + services.RegisterOptionsFactory(configuration => new HttpClientInstrumentationOptions(configuration)); + }); + +#if NETFRAMEWORK + builder.AddSource(HttpWebRequestActivitySource.ActivitySourceName); + + if (builder is IDeferredTracerProviderBuilder deferredTracerProviderBuilder) + { + deferredTracerProviderBuilder.Configure((sp, builder) => + { + var options = sp.GetRequiredService>().Get(name); + + HttpWebRequestActivitySource.Options = options; + }); + } +#else + AddHttpClientInstrumentationSource(builder); + + builder.AddInstrumentation(sp => + { + var options = sp.GetRequiredService>().Get(name); + + return new HttpClientInstrumentation(options); + }); +#endif + return builder; + } + +#if !NETFRAMEWORK + internal static void AddHttpClientInstrumentationSource( + this TracerProviderBuilder builder) + { + if (HttpHandlerDiagnosticListener.IsNet7OrGreater) + { + builder.AddSource(HttpHandlerDiagnosticListener.HttpClientActivitySourceName); + } + else + { + builder.AddSource(HttpHandlerDiagnosticListener.ActivitySourceName); + builder.AddLegacySource("System.Net.Http.HttpRequestOut"); + } + } +#endif + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/HttpRequestMessageContextPropagation.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/HttpRequestMessageContextPropagation.cs new file mode 100644 index 000000000000..ce3475a67c87 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/HttpRequestMessageContextPropagation.cs @@ -0,0 +1,45 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#if NETFRAMEWORK +using System.Net.Http; +#endif + +using System; +using System.Collections.Generic; +using System.Net.Http; + +namespace OpenTelemetry.Instrumentation.Http +{ + internal static class HttpRequestMessageContextPropagation + { + internal static Func> HeaderValuesGetter => (request, name) => + { + if (request.Headers.TryGetValues(name, out var values)) + { + return values; + } + + return null; + }; + + internal static Action HeaderValueSetter => (request, name, value) => + { + request.Headers.Remove(name); + request.Headers.Add(name, value); + }; + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/Implementation/HttpHandlerDiagnosticListener.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/Implementation/HttpHandlerDiagnosticListener.cs new file mode 100644 index 000000000000..ec69d94b3734 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/Implementation/HttpHandlerDiagnosticListener.cs @@ -0,0 +1,308 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using System.Diagnostics; +using System.Linq; +using System.Net.Http; +#if NETFRAMEWORK +using System.Net.Http; +#endif +using System.Reflection; +using System.Threading.Tasks; +using OpenTelemetry.Context.Propagation; +using OpenTelemetry.Trace; +using static OpenTelemetry.Internal.HttpSemanticConventionHelper; + +namespace OpenTelemetry.Instrumentation.Http.Implementation +{ + internal sealed class HttpHandlerDiagnosticListener : ListenerHandler + { + internal static readonly AssemblyName AssemblyName = typeof(HttpHandlerDiagnosticListener).Assembly.GetName(); + internal static readonly bool IsNet7OrGreater; + + // https://github.com/dotnet/runtime/blob/7d034ddbbbe1f2f40c264b323b3ed3d6b3d45e9a/src/libraries/System.Net.Http/src/System/Net/Http/DiagnosticsHandler.cs#L19 + internal static readonly string HttpClientActivitySourceName = "System.Net.Http"; + internal static readonly string ActivitySourceName = AssemblyName.Name + ".HttpClient"; + internal static readonly Version Version = AssemblyName.Version; + internal static readonly ActivitySource ActivitySource = new(ActivitySourceName, Version.ToString()); + + private const string OnStartEvent = "System.Net.Http.HttpRequestOut.Start"; + private const string OnStopEvent = "System.Net.Http.HttpRequestOut.Stop"; + private const string OnUnhandledExceptionEvent = "System.Net.Http.Exception"; + + private readonly PropertyFetcher startRequestFetcher = new("Request"); + private readonly PropertyFetcher stopResponseFetcher = new("Response"); + private readonly PropertyFetcher stopExceptionFetcher = new("Exception"); + private readonly PropertyFetcher stopRequestStatusFetcher = new("RequestTaskStatus"); + private readonly HttpClientInstrumentationOptions options; + private readonly bool emitOldAttributes; + private readonly bool emitNewAttributes; + + static HttpHandlerDiagnosticListener() + { + try + { + IsNet7OrGreater = typeof(HttpClient).Assembly.GetName().Version.Major >= 7; + } + catch (Exception) + { + IsNet7OrGreater = false; + } + } + + public HttpHandlerDiagnosticListener(HttpClientInstrumentationOptions options) + : base("HttpHandlerDiagnosticListener") + { + this.options = options; + + this.emitOldAttributes = this.options.HttpSemanticConvention.HasFlag(HttpSemanticConvention.Old); + + this.emitNewAttributes = this.options.HttpSemanticConvention.HasFlag(HttpSemanticConvention.New); + } + + public override void OnEventWritten(string name, object payload) + { + switch (name) + { + case OnStartEvent: + { + this.OnStartActivity(Activity.Current, payload); + } + + break; + case OnStopEvent: + { + this.OnStopActivity(Activity.Current, payload); + } + + break; + case OnUnhandledExceptionEvent: + { + this.OnException(Activity.Current, payload); + } + + break; + } + } + + public void OnStartActivity(Activity activity, object payload) + { + // The overall flow of what HttpClient library does is as below: + // Activity.Start() + // DiagnosticSource.WriteEvent("Start", payload) + // DiagnosticSource.WriteEvent("Stop", payload) + // Activity.Stop() + + // This method is in the WriteEvent("Start", payload) path. + // By this time, samplers have already run and + // activity.IsAllDataRequested populated accordingly. + + if (Sdk.SuppressInstrumentation) + { + return; + } + + if (!this.startRequestFetcher.TryFetch(payload, out HttpRequestMessage request) || request == null) + { + HttpInstrumentationEventSource.Log.NullPayload(nameof(HttpHandlerDiagnosticListener), nameof(this.OnStartActivity)); + return; + } + + // Propagate context irrespective of sampling decision + var textMapPropagator = Propagators.DefaultTextMapPropagator; + if (textMapPropagator is not TraceContextPropagator) + { + textMapPropagator.Inject(new PropagationContext(activity.Context, Baggage.Current), request, HttpRequestMessageContextPropagation.HeaderValueSetter); + } + + // For .NET7.0 or higher versions, activity is created using activity source. + // However the framework will fallback to creating activity if the sampler's decision is to drop and there is a active diagnostic listener. + // To prevent processing such activities we first check the source name to confirm if it was created using + // activity source or not. + if (IsNet7OrGreater && string.IsNullOrEmpty(activity.Source.Name)) + { + activity.IsAllDataRequested = false; + } + + // enrich Activity from payload only if sampling decision + // is favorable. + if (activity.IsAllDataRequested) + { + try + { + if (this.options.EventFilterHttpRequestMessage(activity.OperationName, request) == false) + { + HttpInstrumentationEventSource.Log.RequestIsFilteredOut(activity.OperationName); + activity.IsAllDataRequested = false; + activity.ActivityTraceFlags &= ~ActivityTraceFlags.Recorded; + return; + } + } + catch (Exception ex) + { + HttpInstrumentationEventSource.Log.RequestFilterException(ex); + activity.IsAllDataRequested = false; + activity.ActivityTraceFlags &= ~ActivityTraceFlags.Recorded; + return; + } + + activity.DisplayName = HttpTagHelper.GetOperationNameForHttpMethod(request.Method); + + if (!IsNet7OrGreater) + { + ActivityInstrumentationHelper.SetActivitySourceProperty(activity, ActivitySource); + ActivityInstrumentationHelper.SetKindProperty(activity, ActivityKind.Client); + } + + // see the spec https://github.com/open-telemetry/opentelemetry-specification/blob/v1.20.0/specification/trace/semantic_conventions/http.md + if (this.emitOldAttributes) + { + activity.SetTag(SemanticConventions.AttributeHttpScheme, request.RequestUri.Scheme); + activity.SetTag(SemanticConventions.AttributeHttpMethod, HttpTagHelper.GetNameForHttpMethod(request.Method)); + activity.SetTag(SemanticConventions.AttributeNetPeerName, request.RequestUri.Host); + if (!request.RequestUri.IsDefaultPort) + { + activity.SetTag(SemanticConventions.AttributeNetPeerPort, request.RequestUri.Port); + } + + activity.SetTag(SemanticConventions.AttributeHttpUrl, HttpTagHelper.GetUriTagValueFromRequestUri(request.RequestUri)); + activity.SetTag(SemanticConventions.AttributeHttpFlavor, HttpTagHelper.GetFlavorTagValueFromProtocolVersion(request.Version)); + } + + // see the spec https://github.com/open-telemetry/semantic-conventions/blob/v1.21.0/docs/http/http-spans.md + if (this.emitNewAttributes) + { + activity.SetTag(SemanticConventions.AttributeHttpRequestMethod, HttpTagHelper.GetNameForHttpMethod(request.Method)); + activity.SetTag(SemanticConventions.AttributeServerAddress, request.RequestUri.Host); + if (!request.RequestUri.IsDefaultPort) + { + activity.SetTag(SemanticConventions.AttributeServerPort, request.RequestUri.Port); + } + + activity.SetTag(SemanticConventions.AttributeUrlFull, HttpTagHelper.GetUriTagValueFromRequestUri(request.RequestUri)); + activity.SetTag(SemanticConventions.AttributeNetworkProtocolVersion, HttpTagHelper.GetFlavorTagValueFromProtocolVersion(request.Version)); + + if (request.Headers.TryGetValues("User-Agent", out var userAgentValues)) + { + var userAgent = userAgentValues.FirstOrDefault(); + if (!string.IsNullOrEmpty(userAgent)) + { + activity.SetTag(SemanticConventions.AttributeHttpUserAgent, userAgent); + } + } + } + + try + { + this.options.EnrichWithHttpRequestMessage?.Invoke(activity, request); + } + catch (Exception ex) + { + HttpInstrumentationEventSource.Log.EnrichmentException(ex); + } + } + } + + public void OnStopActivity(Activity activity, object payload) + { + if (activity.IsAllDataRequested) + { + // https://github.com/dotnet/runtime/blob/master/src/libraries/System.Net.Http/src/System/Net/Http/DiagnosticsHandler.cs + // requestTaskStatus is not null + _ = this.stopRequestStatusFetcher.TryFetch(payload, out var requestTaskStatus); + + ActivityStatusCode currentStatusCode = activity.Status; + if (requestTaskStatus != TaskStatus.RanToCompletion) + { + if (requestTaskStatus == TaskStatus.Canceled) + { + if (currentStatusCode == ActivityStatusCode.Unset) + { + activity.SetStatus(ActivityStatusCode.Error); + } + } + else if (requestTaskStatus != TaskStatus.Faulted) + { + if (currentStatusCode == ActivityStatusCode.Unset) + { + // Faults are handled in OnException and should already have a span.Status of Error w/ Description. + activity.SetStatus(ActivityStatusCode.Error); + } + } + } + + if (this.stopResponseFetcher.TryFetch(payload, out HttpResponseMessage response) && response != null) + { + if (this.emitOldAttributes) + { + activity.SetTag(SemanticConventions.AttributeHttpStatusCode, TelemetryHelper.GetBoxedStatusCode(response.StatusCode)); + } + + if (this.emitNewAttributes) + { + activity.SetTag(SemanticConventions.AttributeHttpResponseStatusCode, TelemetryHelper.GetBoxedStatusCode(response.StatusCode)); + } + + if (currentStatusCode == ActivityStatusCode.Unset) + { + activity.SetStatus(SpanHelper.ResolveSpanStatusForHttpStatusCode(activity.Kind, (int)response.StatusCode)); + } + + try + { + this.options.EnrichWithHttpResponseMessage?.Invoke(activity, response); + } + catch (Exception ex) + { + HttpInstrumentationEventSource.Log.EnrichmentException(ex); + } + } + } + } + + public void OnException(Activity activity, object payload) + { + if (activity.IsAllDataRequested) + { + if (!this.stopExceptionFetcher.TryFetch(payload, out Exception exc) || exc == null) + { + HttpInstrumentationEventSource.Log.NullPayload(nameof(HttpHandlerDiagnosticListener), nameof(this.OnException)); + return; + } + + if (this.options.RecordException) + { + activity.RecordException(exc); + } + + if (exc is HttpRequestException) + { + activity.SetStatus(ActivityStatusCode.Error, exc.Message); + } + + try + { + this.options.EnrichWithException?.Invoke(activity, exc); + } + catch (Exception ex) + { + HttpInstrumentationEventSource.Log.EnrichmentException(ex); + } + } + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/Implementation/HttpHandlerMetricsDiagnosticListener.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/Implementation/HttpHandlerMetricsDiagnosticListener.cs new file mode 100644 index 000000000000..897b8c100437 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/Implementation/HttpHandlerMetricsDiagnosticListener.cs @@ -0,0 +1,110 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System.Collections.Generic; +using System.Diagnostics; +using System.Diagnostics.Metrics; +using System.Net.Http; +#if NETFRAMEWORK +using System.Net.Http; +#endif +using OpenTelemetry.Trace; +using static OpenTelemetry.Internal.HttpSemanticConventionHelper; + +namespace OpenTelemetry.Instrumentation.Http.Implementation +{ + internal sealed class HttpHandlerMetricsDiagnosticListener : ListenerHandler + { + internal const string OnStopEvent = "System.Net.Http.HttpRequestOut.Stop"; + + private readonly PropertyFetcher stopResponseFetcher = new("Response"); + private readonly PropertyFetcher stopRequestFetcher = new("Request"); + private readonly Histogram httpClientDuration; + private readonly HttpClientMetricInstrumentationOptions options; + private readonly bool emitOldAttributes; + private readonly bool emitNewAttributes; + + public HttpHandlerMetricsDiagnosticListener(string name, Meter meter, HttpClientMetricInstrumentationOptions options) + : base(name) + { + this.httpClientDuration = meter.CreateHistogram("http.client.duration", "ms", "Measures the duration of outbound HTTP requests."); + this.options = options; + + this.emitOldAttributes = this.options.HttpSemanticConvention.HasFlag(HttpSemanticConvention.Old); + + this.emitNewAttributes = this.options.HttpSemanticConvention.HasFlag(HttpSemanticConvention.New); + } + + public override void OnEventWritten(string name, object payload) + { + if (name == OnStopEvent) + { + if (Sdk.SuppressInstrumentation) + { + return; + } + + var activity = Activity.Current; + if (this.stopRequestFetcher.TryFetch(payload, out HttpRequestMessage request) && request != null) + { + TagList tags = default; + + // see the spec https://github.com/open-telemetry/opentelemetry-specification/blob/v1.20.0/specification/trace/semantic_conventions/http.md + if (this.emitOldAttributes) + { + tags.Add(new KeyValuePair(SemanticConventions.AttributeHttpMethod, HttpTagHelper.GetNameForHttpMethod(request.Method))); + tags.Add(new KeyValuePair(SemanticConventions.AttributeHttpScheme, request.RequestUri.Scheme)); + tags.Add(new KeyValuePair(SemanticConventions.AttributeHttpFlavor, HttpTagHelper.GetFlavorTagValueFromProtocolVersion(request.Version))); + tags.Add(new KeyValuePair(SemanticConventions.AttributeNetPeerName, request.RequestUri.Host)); + + if (!request.RequestUri.IsDefaultPort) + { + tags.Add(new KeyValuePair(SemanticConventions.AttributeNetPeerPort, request.RequestUri.Port)); + } + + if (this.stopResponseFetcher.TryFetch(payload, out HttpResponseMessage response) && response != null) + { + tags.Add(new KeyValuePair(SemanticConventions.AttributeHttpStatusCode, TelemetryHelper.GetBoxedStatusCode(response.StatusCode))); + } + } + + // see the spec https://github.com/open-telemetry/semantic-conventions/blob/v1.21.0/docs/http/http-spans.md + if (this.emitNewAttributes) + { + tags.Add(new KeyValuePair(SemanticConventions.AttributeHttpRequestMethod, HttpTagHelper.GetNameForHttpMethod(request.Method))); + tags.Add(new KeyValuePair(SemanticConventions.AttributeNetworkProtocolVersion, HttpTagHelper.GetFlavorTagValueFromProtocolVersion(request.Version))); + tags.Add(new KeyValuePair(SemanticConventions.AttributeServerAddress, request.RequestUri.Host)); + + if (!request.RequestUri.IsDefaultPort) + { + tags.Add(new KeyValuePair(SemanticConventions.AttributeServerPort, request.RequestUri.Port)); + } + + if (this.stopResponseFetcher.TryFetch(payload, out HttpResponseMessage response) && response != null) + { + tags.Add(new KeyValuePair(SemanticConventions.AttributeHttpResponseStatusCode, TelemetryHelper.GetBoxedStatusCode(response.StatusCode))); + } + } + + // We are relying here on HttpClient library to set duration before writing the stop event. + // https://github.com/dotnet/runtime/blob/90603686d314147017c8bbe1fa8965776ce607d0/src/libraries/System.Net.Http/src/System/Net/Http/DiagnosticsHandler.cs#L178 + // TODO: Follow up with .NET team if we can continue to rely on this behavior. + this.httpClientDuration.Record(activity.Duration.TotalMilliseconds, tags); + } + } + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/Implementation/HttpInstrumentationEventSource.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/Implementation/HttpInstrumentationEventSource.cs new file mode 100644 index 000000000000..a0a5e6fa9674 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/Implementation/HttpInstrumentationEventSource.cs @@ -0,0 +1,103 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using System.Diagnostics.Tracing; +using OpenTelemetry.Internal; + +namespace OpenTelemetry.Instrumentation.Http.Implementation +{ + /// + /// EventSource events emitted from the project. + /// + [EventSource(Name = "OpenTelemetry-Instrumentation-Http")] + internal sealed class HttpInstrumentationEventSource : EventSource + { + public static HttpInstrumentationEventSource Log = new(); + + [NonEvent] + public void FailedProcessResult(Exception ex) + { + if (this.IsEnabled(EventLevel.Error, EventKeywords.All)) + { + this.FailedProcessResult(ex.ToInvariantString()); + } + } + + [NonEvent] + public void RequestFilterException(Exception ex) + { + if (this.IsEnabled(EventLevel.Error, EventKeywords.All)) + { + this.RequestFilterException(ex.ToInvariantString()); + } + } + + [NonEvent] + public void ExceptionInitializingInstrumentation(string instrumentationType, Exception ex) + { + if (this.IsEnabled(EventLevel.Error, EventKeywords.All)) + { + this.ExceptionInitializingInstrumentation(instrumentationType, ex.ToInvariantString()); + } + } + + [Event(1, Message = "Failed to process result: '{0}'", Level = EventLevel.Error)] + public void FailedProcessResult(string ex) + { + this.WriteEvent(1, ex); + } + + [Event(2, Message = "Error initializing instrumentation type {0}. Exception : {1}", Level = EventLevel.Error)] + public void ExceptionInitializingInstrumentation(string instrumentationType, string ex) + { + this.WriteEvent(2, instrumentationType, ex); + } + + [Event(3, Message = "Payload is NULL in event '{1}' from handler '{0}', span will not be recorded.", Level = EventLevel.Warning)] + public void NullPayload(string handlerName, string eventName) + { + this.WriteEvent(3, handlerName, eventName); + } + + [Event(4, Message = "Filter threw exception. Request will not be collected. Exception {0}.", Level = EventLevel.Error)] + public void RequestFilterException(string exception) + { + this.WriteEvent(4, exception); + } + + [NonEvent] + public void EnrichmentException(Exception ex) + { + if (this.IsEnabled(EventLevel.Error, EventKeywords.All)) + { + this.EnrichmentException(ex.ToInvariantString()); + } + } + + [Event(5, Message = "Enrich threw exception. Exception {0}.", Level = EventLevel.Error)] + public void EnrichmentException(string exception) + { + this.WriteEvent(5, exception); + } + + [Event(6, Message = "Request is filtered out.", Level = EventLevel.Verbose)] + public void RequestIsFilteredOut(string eventName) + { + this.WriteEvent(6, eventName); + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/Implementation/HttpTagHelper.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/Implementation/HttpTagHelper.cs new file mode 100644 index 000000000000..c03700c493a6 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/Implementation/HttpTagHelper.cs @@ -0,0 +1,91 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +using System; +using System.Collections.Concurrent; +using System.Net.Http; +#if NETFRAMEWORK +using System.Net.Http; +#endif + +namespace OpenTelemetry.Instrumentation.Http.Implementation +{ + /// + /// A collection of helper methods to be used when building Http activities. + /// + internal static class HttpTagHelper + { + private static readonly ConcurrentDictionary MethodOperationNameCache = new(); + private static readonly ConcurrentDictionary HttpMethodOperationNameCache = new(); + private static readonly ConcurrentDictionary HttpMethodNameCache = new(); + private static readonly ConcurrentDictionary ProtocolVersionToStringCache = new(); + + private static readonly Func ConvertMethodToOperationNameRef = ConvertMethodToOperationName; + private static readonly Func ConvertHttpMethodToOperationNameRef = ConvertHttpMethodToOperationName; + private static readonly Func ConvertHttpMethodToNameRef = ConvertHttpMethodToName; + private static readonly Func ConvertProtocolVersionToStringRef = ConvertProtocolVersionToString; + + /// + /// Gets the OpenTelemetry standard name for an activity based on its Http method. + /// + /// Http method. + /// Activity name. + public static string GetOperationNameForHttpMethod(string method) => MethodOperationNameCache.GetOrAdd(method, ConvertMethodToOperationNameRef); + + /// + /// Gets the OpenTelemetry standard operation name for a span based on its . + /// + /// . + /// Span operation name. + public static string GetOperationNameForHttpMethod(HttpMethod method) => HttpMethodOperationNameCache.GetOrAdd(method, ConvertHttpMethodToOperationNameRef); + + /// + /// Gets the OpenTelemetry standard method name for a span based on its . + /// + /// . + /// Span method name. + public static string GetNameForHttpMethod(HttpMethod method) => HttpMethodNameCache.GetOrAdd(method, ConvertHttpMethodToNameRef); + + /// + /// Gets the OpenTelemetry standard version tag value for a span based on its protocol . + /// + /// . + /// Span flavor value. + public static string GetFlavorTagValueFromProtocolVersion(Version protocolVersion) => ProtocolVersionToStringCache.GetOrAdd(protocolVersion, ConvertProtocolVersionToStringRef); + + /// + /// Gets the OpenTelemetry standard uri tag value for a span based on its request . + /// + /// . + /// Span uri value. + public static string GetUriTagValueFromRequestUri(Uri uri) + { + if (string.IsNullOrEmpty(uri.UserInfo)) + { + return uri.OriginalString; + } + + return string.Concat(uri.Scheme, Uri.SchemeDelimiter, uri.Authority, uri.PathAndQuery, uri.Fragment); + } + + private static string ConvertMethodToOperationName(string method) => $"HTTP {method}"; + + private static string ConvertHttpMethodToOperationName(HttpMethod method) => $"HTTP {method}"; + + private static string ConvertHttpMethodToName(HttpMethod method) => method.ToString(); + + private static string ConvertProtocolVersionToString(Version protocolVersion) => protocolVersion.ToString(); + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/Implementation/HttpWebRequestActivitySource.netfx.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/Implementation/HttpWebRequestActivitySource.netfx.cs new file mode 100644 index 000000000000..50bf0abd76d0 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/Implementation/HttpWebRequestActivitySource.netfx.cs @@ -0,0 +1,1138 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#if NETFRAMEWORK +using System.Collections; +using System.Diagnostics; +using System.Net; +using System.Reflection; +using System.Reflection.Emit; +using System.Runtime.CompilerServices; +using OpenTelemetry.Context.Propagation; +using OpenTelemetry.Trace; +using static OpenTelemetry.Internal.HttpSemanticConventionHelper; + +namespace OpenTelemetry.Instrumentation.Http.Implementation +{ + /// + /// Hooks into the class reflectively and writes diagnostic events as requests are processed. + /// + /// + /// Inspired from the System.Diagnostics.DiagnosticSource.HttpHandlerDiagnosticListener class which has some bugs and feature gaps. + /// See https://github.com/dotnet/runtime/pull/33732 for details. + /// + internal static class HttpWebRequestActivitySource + { + internal static readonly AssemblyName AssemblyName = typeof(HttpWebRequestActivitySource).Assembly.GetName(); + internal static readonly string ActivitySourceName = AssemblyName.Name + ".HttpWebRequest"; + internal static readonly string ActivityName = ActivitySourceName + ".HttpRequestOut"; + + internal static readonly Func> HttpWebRequestHeaderValuesGetter = (request, name) => request.Headers.GetValues(name); + internal static readonly Action HttpWebRequestHeaderValuesSetter = (request, name, value) => request.Headers.Add(name, value); + + private static readonly Version Version = AssemblyName.Version; + private static readonly ActivitySource WebRequestActivitySource = new ActivitySource(ActivitySourceName, Version.ToString()); + + private static HttpClientInstrumentationOptions options; + + private static bool emitOldAttributes; + private static bool emitNewAttributes; + + // Fields for reflection + private static FieldInfo connectionGroupListField; + private static Type connectionGroupType; + private static FieldInfo connectionListField; + private static Type connectionType; + private static FieldInfo writeListField; + private static Func writeAResultAccessor; + private static Func readAResultAccessor; + + // LazyAsyncResult & ContextAwareResult + private static Func asyncCallbackAccessor; + private static Action asyncCallbackModifier; + private static Func asyncStateAccessor; + private static Action asyncStateModifier; + private static Func endCalledAccessor; + private static Func resultAccessor; + private static Func isContextAwareResultChecker; + + // HttpWebResponse + private static Func httpWebResponseCtor; + private static Func uriAccessor; + private static Func verbAccessor; + private static Func mediaTypeAccessor; + private static Func usesProxySemanticsAccessor; + private static Func coreResponseDataAccessor; + private static Func isWebSocketResponseAccessor; + private static Func connectionGroupNameAccessor; + + static HttpWebRequestActivitySource() + { + try + { + PrepareReflectionObjects(); + PerformInjection(); + + Options = new HttpClientInstrumentationOptions(); + } + catch (Exception ex) + { + // If anything went wrong, just no-op. Write an event so at least we can find out. + HttpInstrumentationEventSource.Log.ExceptionInitializingInstrumentation(typeof(HttpWebRequestActivitySource).FullName, ex); + } + } + + internal static HttpClientInstrumentationOptions Options + { + get => options; + set + { + options = value; + + emitOldAttributes = value.HttpSemanticConvention.HasFlag(HttpSemanticConvention.Old); + emitNewAttributes = value.HttpSemanticConvention.HasFlag(HttpSemanticConvention.New); + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void AddRequestTagsAndInstrumentRequest(HttpWebRequest request, Activity activity) + { + activity.DisplayName = HttpTagHelper.GetOperationNameForHttpMethod(request.Method); + + if (activity.IsAllDataRequested) + { + // see the spec https://github.com/open-telemetry/opentelemetry-specification/blob/v1.20.0/specification/trace/semantic_conventions/http.md + if (emitOldAttributes) + { + activity.SetTag(SemanticConventions.AttributeHttpMethod, request.Method); + activity.SetTag(SemanticConventions.AttributeNetPeerName, request.RequestUri.Host); + if (!request.RequestUri.IsDefaultPort) + { + activity.SetTag(SemanticConventions.AttributeNetPeerPort, request.RequestUri.Port); + } + + activity.SetTag(SemanticConventions.AttributeHttpScheme, request.RequestUri.Scheme); + activity.SetTag(SemanticConventions.AttributeHttpUrl, HttpTagHelper.GetUriTagValueFromRequestUri(request.RequestUri)); + activity.SetTag(SemanticConventions.AttributeHttpFlavor, HttpTagHelper.GetFlavorTagValueFromProtocolVersion(request.ProtocolVersion)); + } + + // see the spec https://github.com/open-telemetry/semantic-conventions/blob/v1.21.0/docs/http/http-spans.md + if (emitNewAttributes) + { + activity.SetTag(SemanticConventions.AttributeHttpRequestMethod, request.Method); + activity.SetTag(SemanticConventions.AttributeServerAddress, request.RequestUri.Host); + if (!request.RequestUri.IsDefaultPort) + { + activity.SetTag(SemanticConventions.AttributeServerPort, request.RequestUri.Port); + } + + activity.SetTag(SemanticConventions.AttributeUrlFull, HttpTagHelper.GetUriTagValueFromRequestUri(request.RequestUri)); + activity.SetTag(SemanticConventions.AttributeNetworkProtocolVersion, HttpTagHelper.GetFlavorTagValueFromProtocolVersion(request.ProtocolVersion)); + } + + try + { + Options.EnrichWithHttpWebRequest?.Invoke(activity, request); + } + catch (Exception ex) + { + HttpInstrumentationEventSource.Log.EnrichmentException(ex); + } + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void AddResponseTags(HttpWebResponse response, Activity activity) + { + if (activity.IsAllDataRequested) + { + if (emitOldAttributes) + { + activity.SetTag(SemanticConventions.AttributeHttpStatusCode, TelemetryHelper.GetBoxedStatusCode(response.StatusCode)); + } + + if (emitNewAttributes) + { + activity.SetTag(SemanticConventions.AttributeHttpResponseStatusCode, TelemetryHelper.GetBoxedStatusCode(response.StatusCode)); + } + + activity.SetStatus(SpanHelper.ResolveSpanStatusForHttpStatusCode(activity.Kind, (int)response.StatusCode)); + + try + { + Options.EnrichWithHttpWebResponse?.Invoke(activity, response); + } + catch (Exception ex) + { + HttpInstrumentationEventSource.Log.EnrichmentException(ex); + } + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void AddExceptionTags(Exception exception, Activity activity) + { + if (!activity.IsAllDataRequested) + { + return; + } + + ActivityStatusCode status; + string exceptionMessage = null; + + if (exception is WebException wexc) + { + if (wexc.Response is HttpWebResponse response) + { + if (emitOldAttributes) + { + activity.SetTag(SemanticConventions.AttributeHttpStatusCode, (int)response.StatusCode); + } + + if (emitNewAttributes) + { + activity.SetTag(SemanticConventions.AttributeHttpResponseStatusCode, (int)response.StatusCode); + } + + status = SpanHelper.ResolveSpanStatusForHttpStatusCode(activity.Kind, (int)response.StatusCode); + } + else + { + switch (wexc.Status) + { + case WebExceptionStatus.Timeout: + case WebExceptionStatus.RequestCanceled: + status = ActivityStatusCode.Error; + break; + case WebExceptionStatus.SendFailure: + case WebExceptionStatus.ConnectFailure: + case WebExceptionStatus.SecureChannelFailure: + case WebExceptionStatus.TrustFailure: + case WebExceptionStatus.ServerProtocolViolation: + case WebExceptionStatus.MessageLengthLimitExceeded: + status = ActivityStatusCode.Error; + exceptionMessage = exception.Message; + break; + default: + status = ActivityStatusCode.Error; + exceptionMessage = exception.Message; + break; + } + } + } + else + { + status = ActivityStatusCode.Error; + exceptionMessage = exception.Message; + } + + activity.SetStatus(status, exceptionMessage); + if (Options.RecordException) + { + activity.RecordException(exception); + } + + try + { + Options.EnrichWithException?.Invoke(activity, exception); + } + catch (Exception ex) + { + HttpInstrumentationEventSource.Log.EnrichmentException(ex); + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void InstrumentRequest(HttpWebRequest request, ActivityContext activityContext) + => Propagators.DefaultTextMapPropagator.Inject(new PropagationContext(activityContext, Baggage.Current), request, HttpWebRequestHeaderValuesSetter); + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static bool IsRequestInstrumented(HttpWebRequest request) + => Propagators.DefaultTextMapPropagator.Extract(default, request, HttpWebRequestHeaderValuesGetter) != default; + + private static void ProcessRequest(HttpWebRequest request) + { + if (!WebRequestActivitySource.HasListeners() || !Options.EventFilterHttpWebRequest(request)) + { + // No subscribers to the ActivitySource or User provider Filter is + // filtering this request. + // Propagation must still be done in such cases, to allow + // downstream services to continue from parent context, if any. + // Eg: Parent could be the Asp.Net activity. + InstrumentRequest(request, Activity.Current?.Context ?? default); + return; + } + + if (IsRequestInstrumented(request)) + { + // This request was instrumented by previous + // ProcessRequest, such is the case with redirect responses where the same request is sent again. + return; + } + + var activity = WebRequestActivitySource.StartActivity(ActivityName, ActivityKind.Client); + var activityContext = Activity.Current?.Context ?? default; + + // Propagation must still be done in all cases, to allow + // downstream services to continue from parent context, if any. + // Eg: Parent could be the Asp.Net activity. + InstrumentRequest(request, activityContext); + if (activity == null) + { + // There is a listener but it decided not to sample the current request. + return; + } + + IAsyncResult asyncContext = writeAResultAccessor(request); + if (asyncContext != null) + { + // Flow here is for [Begin]GetRequestStream[Async]. + + AsyncCallbackWrapper callback = new AsyncCallbackWrapper(request, activity, asyncCallbackAccessor(asyncContext)); + asyncCallbackModifier(asyncContext, callback.AsyncCallback); + } + else + { + // Flow here is for [Begin]GetResponse[Async] without a prior call to [Begin]GetRequestStream[Async]. + + asyncContext = readAResultAccessor(request); + AsyncCallbackWrapper callback = new AsyncCallbackWrapper(request, activity, asyncCallbackAccessor(asyncContext)); + asyncCallbackModifier(asyncContext, callback.AsyncCallback); + } + + AddRequestTagsAndInstrumentRequest(request, activity); + } + + private static void HookOrProcessResult(HttpWebRequest request) + { + IAsyncResult writeAsyncContext = writeAResultAccessor(request); + if (writeAsyncContext == null || !(asyncCallbackAccessor(writeAsyncContext)?.Target is AsyncCallbackWrapper writeAsyncContextCallback)) + { + // If we already hooked into the read result during ProcessRequest or we hooked up after the fact already we don't need to do anything here. + return; + } + + // If we got here it means the user called [Begin]GetRequestStream[Async] and we have to hook the read result after the fact. + + IAsyncResult readAsyncContext = readAResultAccessor(request); + if (readAsyncContext == null) + { + // We're still trying to establish the connection (no read has started). + return; + } + + // Clear our saved callback so we know not to process again. + asyncCallbackModifier(writeAsyncContext, null); + + if (endCalledAccessor.Invoke(readAsyncContext) || readAsyncContext.CompletedSynchronously) + { + // We need to process the result directly because the read callback has already fired. Force a copy because response has likely already been disposed. + ProcessResult(readAsyncContext, null, writeAsyncContextCallback.Activity, resultAccessor(readAsyncContext), true); + return; + } + + // Hook into the result callback if it hasn't already fired. + AsyncCallbackWrapper callback = new AsyncCallbackWrapper(writeAsyncContextCallback.Request, writeAsyncContextCallback.Activity, asyncCallbackAccessor(readAsyncContext)); + asyncCallbackModifier(readAsyncContext, callback.AsyncCallback); + } + + private static void ProcessResult(IAsyncResult asyncResult, AsyncCallback asyncCallback, Activity activity, object result, bool forceResponseCopy) + { + // We could be executing on a different thread now so restore the activity if needed. + if (Activity.Current != activity) + { + Activity.Current = activity; + } + + try + { + if (result is Exception ex) + { + AddExceptionTags(ex, activity); + } + else + { + HttpWebResponse response = (HttpWebResponse)result; + + if (forceResponseCopy || (asyncCallback == null && isContextAwareResultChecker(asyncResult))) + { + // For async calls (where asyncResult is ContextAwareResult)... + // If no callback was set assume the user is manually calling BeginGetResponse & EndGetResponse + // in which case they could dispose the HttpWebResponse before our listeners have a chance to work with it. + // Disposed HttpWebResponse throws when accessing properties, so let's make a copy of the data to ensure that doesn't happen. + + HttpWebResponse responseCopy = httpWebResponseCtor( + new object[] + { + uriAccessor(response), verbAccessor(response), coreResponseDataAccessor(response), mediaTypeAccessor(response), + usesProxySemanticsAccessor(response), DecompressionMethods.None, + isWebSocketResponseAccessor(response), connectionGroupNameAccessor(response), + }); + + AddResponseTags(responseCopy, activity); + } + else + { + AddResponseTags(response, activity); + } + } + } + catch (Exception ex) + { + HttpInstrumentationEventSource.Log.FailedProcessResult(ex); + } + + activity.Stop(); + } + + private static void PrepareReflectionObjects() + { + // At any point, if the operation failed, it should just throw. The caller should catch all exceptions and swallow. + + Type servicePointType = typeof(ServicePoint); + Assembly systemNetHttpAssembly = servicePointType.Assembly; + connectionGroupListField = servicePointType.GetField("m_ConnectionGroupList", BindingFlags.Instance | BindingFlags.NonPublic); + connectionGroupType = systemNetHttpAssembly?.GetType("System.Net.ConnectionGroup"); + connectionListField = connectionGroupType?.GetField("m_ConnectionList", BindingFlags.Instance | BindingFlags.NonPublic); + connectionType = systemNetHttpAssembly?.GetType("System.Net.Connection"); + writeListField = connectionType?.GetField("m_WriteList", BindingFlags.Instance | BindingFlags.NonPublic); + + writeAResultAccessor = CreateFieldGetter(typeof(HttpWebRequest), "_WriteAResult", BindingFlags.NonPublic | BindingFlags.Instance); + readAResultAccessor = CreateFieldGetter(typeof(HttpWebRequest), "_ReadAResult", BindingFlags.NonPublic | BindingFlags.Instance); + + // Double checking to make sure we have all the pieces initialized + if (connectionGroupListField == null || + connectionGroupType == null || + connectionListField == null || + connectionType == null || + writeListField == null || + writeAResultAccessor == null || + readAResultAccessor == null || + !PrepareAsyncResultReflectionObjects(systemNetHttpAssembly) || + !PrepareHttpWebResponseReflectionObjects(systemNetHttpAssembly)) + { + // If anything went wrong here, just return false. There is nothing we can do. + throw new InvalidOperationException("Unable to initialize all required reflection objects"); + } + } + + private static bool PrepareAsyncResultReflectionObjects(Assembly systemNetHttpAssembly) + { + Type lazyAsyncResultType = systemNetHttpAssembly?.GetType("System.Net.LazyAsyncResult"); + if (lazyAsyncResultType != null) + { + asyncCallbackAccessor = CreateFieldGetter(lazyAsyncResultType, "m_AsyncCallback", BindingFlags.NonPublic | BindingFlags.Instance); + asyncCallbackModifier = CreateFieldSetter(lazyAsyncResultType, "m_AsyncCallback", BindingFlags.NonPublic | BindingFlags.Instance); + asyncStateAccessor = CreateFieldGetter(lazyAsyncResultType, "m_AsyncState", BindingFlags.NonPublic | BindingFlags.Instance); + asyncStateModifier = CreateFieldSetter(lazyAsyncResultType, "m_AsyncState", BindingFlags.NonPublic | BindingFlags.Instance); + endCalledAccessor = CreateFieldGetter(lazyAsyncResultType, "m_EndCalled", BindingFlags.NonPublic | BindingFlags.Instance); + resultAccessor = CreateFieldGetter(lazyAsyncResultType, "m_Result", BindingFlags.NonPublic | BindingFlags.Instance); + } + + Type contextAwareResultType = systemNetHttpAssembly?.GetType("System.Net.ContextAwareResult"); + if (contextAwareResultType != null) + { + isContextAwareResultChecker = CreateTypeChecker(contextAwareResultType); + } + + return asyncCallbackAccessor != null + && asyncCallbackModifier != null + && asyncStateAccessor != null + && asyncStateModifier != null + && endCalledAccessor != null + && resultAccessor != null + && isContextAwareResultChecker != null; + } + + private static bool PrepareHttpWebResponseReflectionObjects(Assembly systemNetHttpAssembly) + { + Type knownHttpVerbType = systemNetHttpAssembly?.GetType("System.Net.KnownHttpVerb"); + Type coreResponseData = systemNetHttpAssembly?.GetType("System.Net.CoreResponseData"); + + if (knownHttpVerbType != null && coreResponseData != null) + { + var constructorParameterTypes = new Type[] + { + typeof(Uri), knownHttpVerbType, coreResponseData, typeof(string), + typeof(bool), typeof(DecompressionMethods), + typeof(bool), typeof(string), + }; + + ConstructorInfo ctor = typeof(HttpWebResponse).GetConstructor( + BindingFlags.NonPublic | BindingFlags.Instance, + null, + constructorParameterTypes, + null); + + if (ctor != null) + { + httpWebResponseCtor = CreateTypeInstance(ctor); + } + } + + uriAccessor = CreateFieldGetter("m_Uri", BindingFlags.NonPublic | BindingFlags.Instance); + verbAccessor = CreateFieldGetter("m_Verb", BindingFlags.NonPublic | BindingFlags.Instance); + mediaTypeAccessor = CreateFieldGetter("m_MediaType", BindingFlags.NonPublic | BindingFlags.Instance); + usesProxySemanticsAccessor = CreateFieldGetter("m_UsesProxySemantics", BindingFlags.NonPublic | BindingFlags.Instance); + coreResponseDataAccessor = CreateFieldGetter("m_CoreResponseData", BindingFlags.NonPublic | BindingFlags.Instance); + isWebSocketResponseAccessor = CreateFieldGetter("m_IsWebSocketResponse", BindingFlags.NonPublic | BindingFlags.Instance); + connectionGroupNameAccessor = CreateFieldGetter("m_ConnectionGroupName", BindingFlags.NonPublic | BindingFlags.Instance); + + return httpWebResponseCtor != null + && uriAccessor != null + && verbAccessor != null + && mediaTypeAccessor != null + && usesProxySemanticsAccessor != null + && coreResponseDataAccessor != null + && isWebSocketResponseAccessor != null + && connectionGroupNameAccessor != null; + } + + private static void PerformInjection() + { + FieldInfo servicePointTableField = typeof(ServicePointManager).GetField("s_ServicePointTable", BindingFlags.Static | BindingFlags.NonPublic); + if (servicePointTableField == null) + { + // If anything went wrong here, just return false. There is nothing we can do. + throw new InvalidOperationException("Unable to access the ServicePointTable field"); + } + + Hashtable originalTable = servicePointTableField.GetValue(null) as Hashtable; + ServicePointHashtable newTable = new ServicePointHashtable(originalTable ?? new Hashtable()); + + foreach (DictionaryEntry existingServicePoint in originalTable) + { + HookServicePoint(existingServicePoint.Value); + } + + servicePointTableField.SetValue(null, newTable); + } + + private static void HookServicePoint(object value) + { + if (value is WeakReference weakRef + && weakRef.IsAlive + && weakRef.Target is ServicePoint servicePoint) + { + // Replace the ConnectionGroup hashtable inside this ServicePoint object, + // which allows us to intercept each new ConnectionGroup object added under + // this ServicePoint. + Hashtable originalTable = connectionGroupListField.GetValue(servicePoint) as Hashtable; + ConnectionGroupHashtable newTable = new ConnectionGroupHashtable(originalTable ?? new Hashtable()); + + foreach (DictionaryEntry existingConnectionGroup in originalTable) + { + HookConnectionGroup(existingConnectionGroup.Value); + } + + connectionGroupListField.SetValue(servicePoint, newTable); + } + } + + private static void HookConnectionGroup(object value) + { + if (connectionGroupType.IsInstanceOfType(value)) + { + // Replace the Connection arraylist inside this ConnectionGroup object, + // which allows us to intercept each new Connection object added under + // this ConnectionGroup. + ArrayList originalArrayList = connectionListField.GetValue(value) as ArrayList; + ConnectionArrayList newArrayList = new ConnectionArrayList(originalArrayList ?? new ArrayList()); + + foreach (object connection in originalArrayList) + { + HookConnection(connection); + } + + connectionListField.SetValue(value, newArrayList); + } + } + + private static void HookConnection(object value) + { + if (connectionType.IsInstanceOfType(value)) + { + // Replace the HttpWebRequest arraylist inside this Connection object, + // which allows us to intercept each new HttpWebRequest object added under + // this Connection. + ArrayList originalArrayList = writeListField.GetValue(value) as ArrayList; + HttpWebRequestArrayList newArrayList = new HttpWebRequestArrayList(originalArrayList ?? new ArrayList()); + + writeListField.SetValue(value, newArrayList); + } + } + + private static Func CreateFieldGetter(string fieldName, BindingFlags flags) + where TClass : class + { + FieldInfo field = typeof(TClass).GetField(fieldName, flags); + if (field != null) + { + string methodName = field.ReflectedType.FullName + ".get_" + field.Name; + DynamicMethod getterMethod = new DynamicMethod(methodName, typeof(TField), new[] { typeof(TClass) }, true); + ILGenerator generator = getterMethod.GetILGenerator(); + generator.Emit(OpCodes.Ldarg_0); + generator.Emit(OpCodes.Ldfld, field); + generator.Emit(OpCodes.Ret); + return (Func)getterMethod.CreateDelegate(typeof(Func)); + } + + return null; + } + + /// + /// Creates getter for a field defined in private or internal type + /// repesented with classType variable. + /// + private static Func CreateFieldGetter(Type classType, string fieldName, BindingFlags flags) + { + FieldInfo field = classType.GetField(fieldName, flags); + if (field != null) + { + string methodName = classType.FullName + ".get_" + field.Name; + DynamicMethod getterMethod = new DynamicMethod(methodName, typeof(TField), new[] { typeof(object) }, true); + ILGenerator generator = getterMethod.GetILGenerator(); + generator.Emit(OpCodes.Ldarg_0); + generator.Emit(OpCodes.Castclass, classType); + generator.Emit(OpCodes.Ldfld, field); + generator.Emit(OpCodes.Ret); + + return (Func)getterMethod.CreateDelegate(typeof(Func)); + } + + return null; + } + + /// + /// Creates setter for a field defined in private or internal type + /// repesented with classType variable. + /// + private static Action CreateFieldSetter(Type classType, string fieldName, BindingFlags flags) + { + FieldInfo field = classType.GetField(fieldName, flags); + if (field != null) + { + string methodName = classType.FullName + ".set_" + field.Name; + DynamicMethod setterMethod = new DynamicMethod(methodName, null, new[] { typeof(object), typeof(TField) }, true); + ILGenerator generator = setterMethod.GetILGenerator(); + generator.Emit(OpCodes.Ldarg_0); + generator.Emit(OpCodes.Castclass, classType); + generator.Emit(OpCodes.Ldarg_1); + generator.Emit(OpCodes.Stfld, field); + generator.Emit(OpCodes.Ret); + + return (Action)setterMethod.CreateDelegate(typeof(Action)); + } + + return null; + } + + /// + /// Creates an "is" method for the private or internal type. + /// + private static Func CreateTypeChecker(Type classType) + { + string methodName = classType.FullName + ".typeCheck"; + DynamicMethod setterMethod = new DynamicMethod(methodName, typeof(bool), new[] { typeof(object) }, true); + ILGenerator generator = setterMethod.GetILGenerator(); + generator.Emit(OpCodes.Ldarg_0); + generator.Emit(OpCodes.Isinst, classType); + generator.Emit(OpCodes.Ldnull); + generator.Emit(OpCodes.Cgt_Un); + generator.Emit(OpCodes.Ret); + + return (Func)setterMethod.CreateDelegate(typeof(Func)); + } + + /// + /// Creates an instance of T using a private or internal ctor. + /// + private static Func CreateTypeInstance(ConstructorInfo constructorInfo) + { + Type classType = typeof(T); + string methodName = classType.FullName + ".ctor"; + DynamicMethod setterMethod = new DynamicMethod(methodName, classType, new Type[] { typeof(object[]) }, true); + ILGenerator generator = setterMethod.GetILGenerator(); + + ParameterInfo[] ctorParams = constructorInfo.GetParameters(); + for (int i = 0; i < ctorParams.Length; i++) + { + generator.Emit(OpCodes.Ldarg_0); + switch (i) + { + case 0: generator.Emit(OpCodes.Ldc_I4_0); break; + case 1: generator.Emit(OpCodes.Ldc_I4_1); break; + case 2: generator.Emit(OpCodes.Ldc_I4_2); break; + case 3: generator.Emit(OpCodes.Ldc_I4_3); break; + case 4: generator.Emit(OpCodes.Ldc_I4_4); break; + case 5: generator.Emit(OpCodes.Ldc_I4_5); break; + case 6: generator.Emit(OpCodes.Ldc_I4_6); break; + case 7: generator.Emit(OpCodes.Ldc_I4_7); break; + case 8: generator.Emit(OpCodes.Ldc_I4_8); break; + default: generator.Emit(OpCodes.Ldc_I4, i); break; + } + + generator.Emit(OpCodes.Ldelem_Ref); + Type paramType = ctorParams[i].ParameterType; + generator.Emit(paramType.IsValueType ? OpCodes.Unbox_Any : OpCodes.Castclass, paramType); + } + + generator.Emit(OpCodes.Newobj, constructorInfo); + generator.Emit(OpCodes.Ret); + + return (Func)setterMethod.CreateDelegate(typeof(Func)); + } + + private class HashtableWrapper : Hashtable, IEnumerable + { + private readonly Hashtable table; + + internal HashtableWrapper(Hashtable table) + : base() + { + this.table = table; + } + + public override int Count => this.table.Count; + + public override bool IsReadOnly => this.table.IsReadOnly; + + public override bool IsFixedSize => this.table.IsFixedSize; + + public override bool IsSynchronized => this.table.IsSynchronized; + + public override object SyncRoot => this.table.SyncRoot; + + public override ICollection Keys => this.table.Keys; + + public override ICollection Values => this.table.Values; + + public override object this[object key] + { + get => this.table[key]; + set => this.table[key] = value; + } + + public override void Add(object key, object value) + { + this.table.Add(key, value); + } + + public override void Clear() + { + this.table.Clear(); + } + + public override bool Contains(object key) + { + return this.table.Contains(key); + } + + public override bool ContainsKey(object key) + { + return this.table.ContainsKey(key); + } + + public override bool ContainsValue(object key) + { + return this.table.ContainsValue(key); + } + + public override void CopyTo(Array array, int arrayIndex) + { + this.table.CopyTo(array, arrayIndex); + } + + public override object Clone() + { + return new HashtableWrapper((Hashtable)this.table.Clone()); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return this.table.GetEnumerator(); + } + + public override IDictionaryEnumerator GetEnumerator() + { + return this.table.GetEnumerator(); + } + + public override void Remove(object key) + { + this.table.Remove(key); + } + } + + /// + /// Helper class used for ServicePointManager.s_ServicePointTable. The goal here is to + /// intercept each new ServicePoint object being added to ServicePointManager.s_ServicePointTable + /// and replace its ConnectionGroupList hashtable field. + /// + private sealed class ServicePointHashtable : HashtableWrapper + { + public ServicePointHashtable(Hashtable table) + : base(table) + { + } + + public override object this[object key] + { + get => base[key]; + set + { + HookServicePoint(value); + base[key] = value; + } + } + } + + /// + /// Helper class used for ServicePoint.m_ConnectionGroupList. The goal here is to + /// intercept each new ConnectionGroup object being added to ServicePoint.m_ConnectionGroupList + /// and replace its m_ConnectionList arraylist field. + /// + private sealed class ConnectionGroupHashtable : HashtableWrapper + { + public ConnectionGroupHashtable(Hashtable table) + : base(table) + { + } + + public override object this[object key] + { + get => base[key]; + set + { + HookConnectionGroup(value); + base[key] = value; + } + } + } + + /// + /// Helper class used to wrap the array list object. This class itself doesn't actually + /// have the array elements, but rather access another array list that's given at + /// construction time. + /// + private class ArrayListWrapper : ArrayList + { + private ArrayList list; + + internal ArrayListWrapper(ArrayList list) + : base() + { + this.list = list; + } + + public override int Capacity + { + get => this.list.Capacity; + set => this.list.Capacity = value; + } + + public override int Count => this.list.Count; + + public override bool IsReadOnly => this.list.IsReadOnly; + + public override bool IsFixedSize => this.list.IsFixedSize; + + public override bool IsSynchronized => this.list.IsSynchronized; + + public override object SyncRoot => this.list.SyncRoot; + + public override object this[int index] + { + get => this.list[index]; + set => this.list[index] = value; + } + + public override int Add(object value) + { + return this.list.Add(value); + } + + public override void AddRange(ICollection c) + { + this.list.AddRange(c); + } + + public override int BinarySearch(object value) + { + return this.list.BinarySearch(value); + } + + public override int BinarySearch(object value, IComparer comparer) + { + return this.list.BinarySearch(value, comparer); + } + + public override int BinarySearch(int index, int count, object value, IComparer comparer) + { + return this.list.BinarySearch(index, count, value, comparer); + } + + public override void Clear() + { + this.list.Clear(); + } + + public override object Clone() + { + return new ArrayListWrapper((ArrayList)this.list.Clone()); + } + + public override bool Contains(object item) + { + return this.list.Contains(item); + } + + public override void CopyTo(Array array) + { + this.list.CopyTo(array); + } + + public override void CopyTo(Array array, int index) + { + this.list.CopyTo(array, index); + } + + public override void CopyTo(int index, Array array, int arrayIndex, int count) + { + this.list.CopyTo(index, array, arrayIndex, count); + } + + public override IEnumerator GetEnumerator() + { + return this.list.GetEnumerator(); + } + + public override IEnumerator GetEnumerator(int index, int count) + { + return this.list.GetEnumerator(index, count); + } + + public override int IndexOf(object value) + { + return this.list.IndexOf(value); + } + + public override int IndexOf(object value, int startIndex) + { + return this.list.IndexOf(value, startIndex); + } + + public override int IndexOf(object value, int startIndex, int count) + { + return this.list.IndexOf(value, startIndex, count); + } + + public override void Insert(int index, object value) + { + this.list.Insert(index, value); + } + + public override void InsertRange(int index, ICollection c) + { + this.list.InsertRange(index, c); + } + + public override int LastIndexOf(object value) + { + return this.list.LastIndexOf(value); + } + + public override int LastIndexOf(object value, int startIndex) + { + return this.list.LastIndexOf(value, startIndex); + } + + public override int LastIndexOf(object value, int startIndex, int count) + { + return this.list.LastIndexOf(value, startIndex, count); + } + + public override void Remove(object value) + { + this.list.Remove(value); + } + + public override void RemoveAt(int index) + { + this.list.RemoveAt(index); + } + + public override void RemoveRange(int index, int count) + { + this.list.RemoveRange(index, count); + } + + public override void Reverse(int index, int count) + { + this.list.Reverse(index, count); + } + + public override void SetRange(int index, ICollection c) + { + this.list.SetRange(index, c); + } + + public override ArrayList GetRange(int index, int count) + { + return this.list.GetRange(index, count); + } + + public override void Sort() + { + this.list.Sort(); + } + + public override void Sort(IComparer comparer) + { + this.list.Sort(comparer); + } + + public override void Sort(int index, int count, IComparer comparer) + { + this.list.Sort(index, count, comparer); + } + + public override object[] ToArray() + { + return this.list.ToArray(); + } + + public override Array ToArray(Type type) + { + return this.list.ToArray(type); + } + + public override void TrimToSize() + { + this.list.TrimToSize(); + } + + public ArrayList Swap() + { + ArrayList old = this.list; + this.list = new ArrayList(old.Capacity); + return old; + } + } + + /// + /// Helper class used for ConnectionGroup.m_ConnectionList. The goal here is to + /// intercept each new Connection object being added to ConnectionGroup.m_ConnectionList + /// and replace its m_WriteList arraylist field. + /// + private sealed class ConnectionArrayList : ArrayListWrapper + { + public ConnectionArrayList(ArrayList list) + : base(list) + { + } + + public override int Add(object value) + { + HookConnection(value); + return base.Add(value); + } + } + + /// + /// Helper class used for Connection.m_WriteList. The goal here is to + /// intercept all new HttpWebRequest objects being added to Connection.m_WriteList + /// and notify the listener about the HttpWebRequest that's about to send a request. + /// It also intercepts all HttpWebRequest objects that are about to get removed from + /// Connection.m_WriteList as they have completed the request. + /// + private sealed class HttpWebRequestArrayList : ArrayListWrapper + { + public HttpWebRequestArrayList(ArrayList list) + : base(list) + { + } + + public override int Add(object value) + { + // Add before firing events so if some user code cancels/aborts the request it will be found in the outstanding list. + int index = base.Add(value); + + if (value is HttpWebRequest request) + { + ProcessRequest(request); + } + + return index; + } + + public override void RemoveAt(int index) + { + object request = this[index]; + + base.RemoveAt(index); + + if (request is HttpWebRequest webRequest) + { + HookOrProcessResult(webRequest); + } + } + + public override void Clear() + { + ArrayList oldList = this.Swap(); + for (int i = 0; i < oldList.Count; i++) + { + if (oldList[i] is HttpWebRequest request) + { + HookOrProcessResult(request); + } + } + } + } + + /// + /// A closure object so our state is available when our callback executes. + /// + private sealed class AsyncCallbackWrapper + { + public AsyncCallbackWrapper(HttpWebRequest request, Activity activity, AsyncCallback originalCallback) + { + this.Request = request; + this.Activity = activity; + this.OriginalCallback = originalCallback; + } + + public HttpWebRequest Request { get; } + + public Activity Activity { get; } + + public AsyncCallback OriginalCallback { get; } + + public void AsyncCallback(IAsyncResult asyncResult) + { + object result = resultAccessor(asyncResult); + if (result is Exception || result is HttpWebResponse) + { + ProcessResult(asyncResult, this.OriginalCallback, this.Activity, result, false); + } + + this.OriginalCallback?.Invoke(asyncResult); + } + } + } +} +#endif diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/Implementation/TelemetryHelper.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/Implementation/TelemetryHelper.cs new file mode 100644 index 000000000000..9b53a5bc5f6f --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.Http/Implementation/TelemetryHelper.cs @@ -0,0 +1,44 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System.Net; + +namespace OpenTelemetry.Instrumentation.Http.Implementation; + +internal static class TelemetryHelper +{ + public static readonly object[] BoxedStatusCodes; + + static TelemetryHelper() + { + BoxedStatusCodes = new object[500]; + for (int i = 0, c = 100; i < BoxedStatusCodes.Length; i++, c++) + { + BoxedStatusCodes[i] = c; + } + } + + public static object GetBoxedStatusCode(HttpStatusCode statusCode) + { + int intStatusCode = (int)statusCode; + if (intStatusCode >= 100 && intStatusCode < 600) + { + return BoxedStatusCodes[intStatusCode - 100]; + } + + return intStatusCode; + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.SqlClient/Implementation/SqlActivitySourceHelper.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.SqlClient/Implementation/SqlActivitySourceHelper.cs new file mode 100644 index 000000000000..fbf4fb7d83ac --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.SqlClient/Implementation/SqlActivitySourceHelper.cs @@ -0,0 +1,43 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Reflection; +using OpenTelemetry.Trace; + +namespace OpenTelemetry.Instrumentation.SqlClient.Implementation +{ + /// + /// Helper class to hold common properties used by both SqlClientDiagnosticListener on .NET Core + /// and SqlEventSourceListener on .NET Framework. + /// + internal sealed class SqlActivitySourceHelper + { + public const string MicrosoftSqlServerDatabaseSystemName = "mssql"; + + public static readonly AssemblyName AssemblyName = typeof(SqlActivitySourceHelper).Assembly.GetName(); + public static readonly string ActivitySourceName = AssemblyName.Name; + public static readonly Version Version = AssemblyName.Version; + public static readonly ActivitySource ActivitySource = new(ActivitySourceName, Version.ToString()); + public static readonly string ActivityName = ActivitySourceName + ".Execute"; + + public static readonly IEnumerable> CreationTags = new[] + { + new KeyValuePair(SemanticConventions.AttributeDbSystem, MicrosoftSqlServerDatabaseSystemName), + }; + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.SqlClient/Implementation/SqlClientDiagnosticListener.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.SqlClient/Implementation/SqlClientDiagnosticListener.cs new file mode 100644 index 000000000000..b383ab03896b --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.SqlClient/Implementation/SqlClientDiagnosticListener.cs @@ -0,0 +1,215 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#if !NETFRAMEWORK +using System; +using System.Data; +using System.Diagnostics; +using OpenTelemetry.Trace; + +namespace OpenTelemetry.Instrumentation.SqlClient.Implementation +{ + internal sealed class SqlClientDiagnosticListener : ListenerHandler + { + public const string SqlDataBeforeExecuteCommand = "System.Data.SqlClient.WriteCommandBefore"; + public const string SqlMicrosoftBeforeExecuteCommand = "Microsoft.Data.SqlClient.WriteCommandBefore"; + + public const string SqlDataAfterExecuteCommand = "System.Data.SqlClient.WriteCommandAfter"; + public const string SqlMicrosoftAfterExecuteCommand = "Microsoft.Data.SqlClient.WriteCommandAfter"; + + public const string SqlDataWriteCommandError = "System.Data.SqlClient.WriteCommandError"; + public const string SqlMicrosoftWriteCommandError = "Microsoft.Data.SqlClient.WriteCommandError"; + + private readonly PropertyFetcher commandFetcher = new("Command"); + private readonly PropertyFetcher connectionFetcher = new("Connection"); + private readonly PropertyFetcher dataSourceFetcher = new("DataSource"); + private readonly PropertyFetcher databaseFetcher = new("Database"); + private readonly PropertyFetcher commandTypeFetcher = new("CommandType"); + private readonly PropertyFetcher commandTextFetcher = new("CommandText"); + private readonly PropertyFetcher exceptionFetcher = new("Exception"); + private readonly SqlClientInstrumentationOptions options; + + public SqlClientDiagnosticListener(string sourceName, SqlClientInstrumentationOptions options) + : base(sourceName) + { + this.options = options ?? new SqlClientInstrumentationOptions(); + } + + public override bool SupportsNullActivity => true; + + public override void OnEventWritten(string name, object payload) + { + var activity = Activity.Current; + switch (name) + { + case SqlDataBeforeExecuteCommand: + case SqlMicrosoftBeforeExecuteCommand: + { + // SqlClient does not create an Activity. So the activity coming in here will be null or the root span. + activity = SqlActivitySourceHelper.ActivitySource.StartActivity( + SqlActivitySourceHelper.ActivityName, + ActivityKind.Client, + default(ActivityContext), + SqlActivitySourceHelper.CreationTags); + + if (activity == null) + { + // There is no listener or it decided not to sample the current request. + return; + } + + _ = this.commandFetcher.TryFetch(payload, out var command); + if (command == null) + { + SqlClientInstrumentationEventSource.Log.NullPayload(nameof(SqlClientDiagnosticListener), name); + activity.Stop(); + return; + } + + if (activity.IsAllDataRequested) + { + try + { + if (this.options.Filter?.Invoke(command) == false) + { + SqlClientInstrumentationEventSource.Log.CommandIsFilteredOut(activity.OperationName); + activity.IsAllDataRequested = false; + activity.ActivityTraceFlags &= ~ActivityTraceFlags.Recorded; + return; + } + } + catch (Exception ex) + { + SqlClientInstrumentationEventSource.Log.CommandFilterException(ex); + activity.IsAllDataRequested = false; + activity.ActivityTraceFlags &= ~ActivityTraceFlags.Recorded; + return; + } + + _ = this.connectionFetcher.TryFetch(command, out var connection); + _ = this.databaseFetcher.TryFetch(connection, out var database); + + activity.DisplayName = (string)database; + + _ = this.dataSourceFetcher.TryFetch(connection, out var dataSource); + _ = this.commandTextFetcher.TryFetch(command, out var commandText); + + activity.SetTag(SemanticConventions.AttributeDbName, (string)database); + + this.options.AddConnectionLevelDetailsToActivity((string)dataSource, activity); + + if (this.commandTypeFetcher.TryFetch(command, out CommandType commandType)) + { + switch (commandType) + { + case CommandType.StoredProcedure: + activity.SetTag(SpanAttributeConstants.DatabaseStatementTypeKey, nameof(CommandType.StoredProcedure)); + if (this.options.SetDbStatementForStoredProcedure) + { + activity.SetTag(SemanticConventions.AttributeDbStatement, (string)commandText); + } + + break; + + case CommandType.Text: + activity.SetTag(SpanAttributeConstants.DatabaseStatementTypeKey, nameof(CommandType.Text)); + if (this.options.SetDbStatementForText) + { + activity.SetTag(SemanticConventions.AttributeDbStatement, (string)commandText); + } + + break; + + case CommandType.TableDirect: + activity.SetTag(SpanAttributeConstants.DatabaseStatementTypeKey, nameof(CommandType.TableDirect)); + break; + } + } + + try + { + this.options.Enrich?.Invoke(activity, "OnCustom", command); + } + catch (Exception ex) + { + SqlClientInstrumentationEventSource.Log.EnrichmentException(ex); + } + } + } + + break; + case SqlDataAfterExecuteCommand: + case SqlMicrosoftAfterExecuteCommand: + { + if (activity == null) + { + SqlClientInstrumentationEventSource.Log.NullActivity(name); + return; + } + + if (activity.Source != SqlActivitySourceHelper.ActivitySource) + { + return; + } + + activity.Stop(); + } + + break; + case SqlDataWriteCommandError: + case SqlMicrosoftWriteCommandError: + { + if (activity == null) + { + SqlClientInstrumentationEventSource.Log.NullActivity(name); + return; + } + + if (activity.Source != SqlActivitySourceHelper.ActivitySource) + { + return; + } + + try + { + if (activity.IsAllDataRequested) + { + if (this.exceptionFetcher.TryFetch(payload, out Exception exception) && exception != null) + { + activity.SetStatus(ActivityStatusCode.Error, exception.Message); + + if (this.options.RecordException) + { + activity.RecordException(exception); + } + } + else + { + SqlClientInstrumentationEventSource.Log.NullPayload(nameof(SqlClientDiagnosticListener), name); + } + } + } + finally + { + activity.Stop(); + } + } + + break; + } + } + } +} +#endif diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.SqlClient/Implementation/SqlClientInstrumentationEventSource.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.SqlClient/Implementation/SqlClientInstrumentationEventSource.cs new file mode 100644 index 000000000000..31a7a9737bfd --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.SqlClient/Implementation/SqlClientInstrumentationEventSource.cs @@ -0,0 +1,100 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using System.Diagnostics.Tracing; +using OpenTelemetry.Internal; + +namespace OpenTelemetry.Instrumentation.SqlClient.Implementation +{ + /// + /// EventSource events emitted from the project. + /// + [EventSource(Name = "OpenTelemetry-Instrumentation-SqlClient")] + internal sealed class SqlClientInstrumentationEventSource : EventSource + { + public static SqlClientInstrumentationEventSource Log = new(); + + [NonEvent] + public void UnknownErrorProcessingEvent(string handlerName, string eventName, Exception ex) + { + if (this.IsEnabled(EventLevel.Error, EventKeywords.All)) + { + this.UnknownErrorProcessingEvent(handlerName, eventName, ex.ToInvariantString()); + } + } + + [Event(1, Message = "Unknown error processing event '{1}' from handler '{0}', Exception: {2}", Level = EventLevel.Error)] + public void UnknownErrorProcessingEvent(string handlerName, string eventName, string ex) + { + this.WriteEvent(1, handlerName, eventName, ex); + } + + [Event(2, Message = "Current Activity is NULL in the '{0}' callback. Span will not be recorded.", Level = EventLevel.Warning)] + public void NullActivity(string eventName) + { + this.WriteEvent(2, eventName); + } + + [Event(3, Message = "Payload is NULL in event '{1}' from handler '{0}', span will not be recorded.", Level = EventLevel.Warning)] + public void NullPayload(string handlerName, string eventName) + { + this.WriteEvent(3, handlerName, eventName); + } + + [Event(4, Message = "Payload is invalid in event '{1}' from handler '{0}', span will not be recorded.", Level = EventLevel.Warning)] + public void InvalidPayload(string handlerName, string eventName) + { + this.WriteEvent(4, handlerName, eventName); + } + + [NonEvent] + public void EnrichmentException(Exception ex) + { + if (this.IsEnabled(EventLevel.Error, EventKeywords.All)) + { + this.EnrichmentException(ex.ToInvariantString()); + } + } + + [Event(5, Message = "Enrichment threw exception. Exception {0}.", Level = EventLevel.Error)] + public void EnrichmentException(string exception) + { + this.WriteEvent(5, exception); + } + + [Event(6, Message = "Command is filtered out. Activity {0}", Level = EventLevel.Verbose)] + public void CommandIsFilteredOut(string activityName) + { + this.WriteEvent(6, activityName); + } + + [NonEvent] + public void CommandFilterException(Exception ex) + { + if (this.IsEnabled(EventLevel.Error, EventKeywords.All)) + { + this.CommandFilterException(ex.ToInvariantString()); + } + } + + [Event(7, Message = "Command filter threw exception. Command will not be collected. Exception {0}.", Level = EventLevel.Error)] + public void CommandFilterException(string exception) + { + this.WriteEvent(7, exception); + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.SqlClient/Implementation/SqlEventSourceListener.netfx.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.SqlClient/Implementation/SqlEventSourceListener.netfx.cs new file mode 100644 index 000000000000..a06c77c428c1 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.SqlClient/Implementation/SqlEventSourceListener.netfx.cs @@ -0,0 +1,205 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#if NETFRAMEWORK +using System.Diagnostics; +using System.Diagnostics.Tracing; +using OpenTelemetry.Trace; + +namespace OpenTelemetry.Instrumentation.SqlClient.Implementation +{ + /// + /// On .NET Framework, neither System.Data.SqlClient nor Microsoft.Data.SqlClient emit DiagnosticSource events. + /// Instead they use EventSource: + /// For System.Data.SqlClient see: reference source. + /// For Microsoft.Data.SqlClient see: SqlClientEventSource. + /// + /// We hook into these event sources and process their BeginExecute/EndExecute events. + /// + /// + /// Note that before version 2.0.0, Microsoft.Data.SqlClient used + /// "Microsoft-AdoNet-SystemData" (same as System.Data.SqlClient), but since + /// 2.0.0 has switched to "Microsoft.Data.SqlClient.EventSource". + /// + internal sealed class SqlEventSourceListener : EventListener + { + internal const string AdoNetEventSourceName = "Microsoft-AdoNet-SystemData"; + internal const string MdsEventSourceName = "Microsoft.Data.SqlClient.EventSource"; + + internal const int BeginExecuteEventId = 1; + internal const int EndExecuteEventId = 2; + + private readonly SqlClientInstrumentationOptions options; + private EventSource adoNetEventSource; + private EventSource mdsEventSource; + + public SqlEventSourceListener(SqlClientInstrumentationOptions options = null) + { + this.options = options ?? new SqlClientInstrumentationOptions(); + } + + public override void Dispose() + { + if (this.adoNetEventSource != null) + { + this.DisableEvents(this.adoNetEventSource); + } + + if (this.mdsEventSource != null) + { + this.DisableEvents(this.mdsEventSource); + } + + base.Dispose(); + } + + protected override void OnEventSourceCreated(EventSource eventSource) + { + if (eventSource?.Name.StartsWith(AdoNetEventSourceName, StringComparison.Ordinal) == true) + { + this.adoNetEventSource = eventSource; + this.EnableEvents(eventSource, EventLevel.Informational, EventKeywords.All); + } + else if (eventSource?.Name.StartsWith(MdsEventSourceName, StringComparison.Ordinal) == true) + { + this.mdsEventSource = eventSource; + this.EnableEvents(eventSource, EventLevel.Informational, EventKeywords.All); + } + + base.OnEventSourceCreated(eventSource); + } + + protected override void OnEventWritten(EventWrittenEventArgs eventData) + { + try + { + if (eventData.EventId == BeginExecuteEventId) + { + this.OnBeginExecute(eventData); + } + else if (eventData.EventId == EndExecuteEventId) + { + this.OnEndExecute(eventData); + } + } + catch (Exception exc) + { + SqlClientInstrumentationEventSource.Log.UnknownErrorProcessingEvent(nameof(SqlEventSourceListener), nameof(this.OnEventWritten), exc); + } + } + + private void OnBeginExecute(EventWrittenEventArgs eventData) + { + /* + Expected payload: + [0] -> ObjectId + [1] -> DataSource + [2] -> Database + [3] -> CommandText + + Note: + - For "Microsoft-AdoNet-SystemData" v1.0: [3] CommandText = CommandType == CommandType.StoredProcedure ? CommandText : string.Empty; (so it is set for only StoredProcedure command types) + (https://github.com/dotnet/SqlClient/blob/v1.0.19239.1/src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/SqlCommand.cs#L6369) + - For "Microsoft-AdoNet-SystemData" v1.1: [3] CommandText = sqlCommand.CommandText (so it is set for all command types) + (https://github.com/dotnet/SqlClient/blob/v1.1.0/src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/SqlCommand.cs#L7459) + - For "Microsoft.Data.SqlClient.EventSource" v2.0+: [3] CommandText = sqlCommand.CommandText (so it is set for all command types). + (https://github.com/dotnet/SqlClient/blob/f4568ce68da21db3fe88c0e72e1287368aaa1dc8/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SqlCommand.cs#L6641) + */ + + if ((eventData?.Payload?.Count ?? 0) < 4) + { + SqlClientInstrumentationEventSource.Log.InvalidPayload(nameof(SqlEventSourceListener), nameof(this.OnBeginExecute)); + return; + } + + var activity = SqlActivitySourceHelper.ActivitySource.StartActivity( + SqlActivitySourceHelper.ActivityName, + ActivityKind.Client, + default(ActivityContext), + SqlActivitySourceHelper.CreationTags); + + if (activity == null) + { + // There is no listener or it decided not to sample the current request. + return; + } + + string databaseName = (string)eventData.Payload[2]; + + activity.DisplayName = databaseName; + + if (activity.IsAllDataRequested) + { + activity.SetTag(SemanticConventions.AttributeDbName, databaseName); + + this.options.AddConnectionLevelDetailsToActivity((string)eventData.Payload[1], activity); + + string commandText = (string)eventData.Payload[3]; + if (!string.IsNullOrEmpty(commandText) && this.options.SetDbStatementForText) + { + activity.SetTag(SemanticConventions.AttributeDbStatement, commandText); + } + } + } + + private void OnEndExecute(EventWrittenEventArgs eventData) + { + /* + Expected payload: + [0] -> ObjectId + [1] -> CompositeState bitmask (0b001 -> successFlag, 0b010 -> isSqlExceptionFlag , 0b100 -> synchronousFlag) + [2] -> SqlExceptionNumber + */ + + if ((eventData?.Payload?.Count ?? 0) < 3) + { + SqlClientInstrumentationEventSource.Log.InvalidPayload(nameof(SqlEventSourceListener), nameof(this.OnEndExecute)); + return; + } + + var activity = Activity.Current; + if (activity?.Source != SqlActivitySourceHelper.ActivitySource) + { + return; + } + + try + { + if (activity.IsAllDataRequested) + { + int compositeState = (int)eventData.Payload[1]; + if ((compositeState & 0b001) != 0b001) + { + if ((compositeState & 0b010) == 0b010) + { + var errorText = $"SqlExceptionNumber {eventData.Payload[2]} thrown."; + activity.SetStatus(ActivityStatusCode.Error, errorText); + } + else + { + activity.SetStatus(ActivityStatusCode.Error, "Unknown Sql failure."); + } + } + } + } + finally + { + activity.Stop(); + } + } + } +} +#endif diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.SqlClient/SqlClientInstrumentation.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.SqlClient/SqlClientInstrumentation.cs new file mode 100644 index 000000000000..10e1eb8d3a21 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.SqlClient/SqlClientInstrumentation.cs @@ -0,0 +1,77 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using System.Collections.Generic; +using OpenTelemetry.Instrumentation.SqlClient.Implementation; + +namespace OpenTelemetry.Instrumentation.SqlClient +{ + /// + /// SqlClient instrumentation. + /// + internal sealed class SqlClientInstrumentation : IDisposable + { + internal const string SqlClientDiagnosticListenerName = "SqlClientDiagnosticListener"; + +#if NETFRAMEWORK + private readonly SqlEventSourceListener sqlEventSourceListener; +#else + private static readonly HashSet DiagnosticSourceEvents = new() + { + "System.Data.SqlClient.WriteCommandBefore", + "Microsoft.Data.SqlClient.WriteCommandBefore", + "System.Data.SqlClient.WriteCommandAfter", + "Microsoft.Data.SqlClient.WriteCommandAfter", + "System.Data.SqlClient.WriteCommandError", + "Microsoft.Data.SqlClient.WriteCommandError", + }; + + private readonly Func isEnabled = (eventName, _, _) + => DiagnosticSourceEvents.Contains(eventName); + + private readonly DiagnosticSourceSubscriber diagnosticSourceSubscriber; +#endif + + /// + /// Initializes a new instance of the class. + /// + /// Configuration options for sql instrumentation. + public SqlClientInstrumentation( + SqlClientInstrumentationOptions options = null) + { +#if NETFRAMEWORK + this.sqlEventSourceListener = new SqlEventSourceListener(options); +#else + this.diagnosticSourceSubscriber = new DiagnosticSourceSubscriber( + name => new SqlClientDiagnosticListener(name, options), + listener => listener.Name == SqlClientDiagnosticListenerName, + this.isEnabled); + this.diagnosticSourceSubscriber.Subscribe(); +#endif + } + + /// + public void Dispose() + { +#if NETFRAMEWORK + this.sqlEventSourceListener?.Dispose(); +#else + this.diagnosticSourceSubscriber?.Dispose(); +#endif + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.SqlClient/SqlClientInstrumentationOptions.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.SqlClient/SqlClientInstrumentationOptions.cs new file mode 100644 index 000000000000..e06b564cd78e --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.SqlClient/SqlClientInstrumentationOptions.cs @@ -0,0 +1,367 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using System.Collections.Concurrent; +using System.Data; +using System.Diagnostics; +using System.Text.RegularExpressions; +using Microsoft.Extensions.Configuration; +using OpenTelemetry.Trace; +using static OpenTelemetry.Internal.HttpSemanticConventionHelper; + +namespace OpenTelemetry.Instrumentation.SqlClient +{ + /// + /// Options for . + /// + /// + /// For help and examples see: . + /// + internal class SqlClientInstrumentationOptions + { + /* + * Match... + * protocol[ ]:[ ]serverName + * serverName + * serverName[ ]\[ ]instanceName + * serverName[ ],[ ]port + * serverName[ ]\[ ]instanceName[ ],[ ]port + * + * [ ] can be any number of white-space, SQL allows it for some reason. + * + * Optional "protocol" can be "tcp", "lpc" (shared memory), or "np" (named pipes). See: + * https://docs.microsoft.com/troubleshoot/sql/connect/use-server-name-parameter-connection-string, and + * https://docs.microsoft.com/dotnet/api/system.data.sqlclient.sqlconnection.connectionstring?view=dotnet-plat-ext-5.0 + * + * In case of named pipes the Data Source string can take form of: + * np:serverName\instanceName, or + * np:\\serverName\pipe\pipeName, or + * np:\\serverName\pipe\MSSQL$instanceName\pipeName - in this case a separate regex (see NamedPipeRegex below) + * is used to extract instanceName + */ + private static readonly Regex DataSourceRegex = new("^(.*\\s*:\\s*\\\\{0,2})?(.*?)\\s*(?:[\\\\,]|$)\\s*(.*?)\\s*(?:,|$)\\s*(.*)$", RegexOptions.Compiled); + + /// + /// In a Data Source string like "np:\\serverName\pipe\MSSQL$instanceName\pipeName" match the + /// "pipe\MSSQL$instanceName" segment to extract instanceName if it is available. + /// + /// + /// + /// + private static readonly Regex NamedPipeRegex = new("pipe\\\\MSSQL\\$(.*?)\\\\", RegexOptions.Compiled); + + private static readonly ConcurrentDictionary ConnectionDetailCache = new(StringComparer.OrdinalIgnoreCase); + + private readonly bool emitOldAttributes; + private readonly bool emitNewAttributes; + + /// + /// Initializes a new instance of the class. + /// + public SqlClientInstrumentationOptions() + : this(new ConfigurationBuilder().AddEnvironmentVariables().Build()) + { + } + + internal SqlClientInstrumentationOptions(IConfiguration configuration) + { + Debug.Assert(configuration != null, "configuration was null"); + + var httpSemanticConvention = GetSemanticConventionOptIn(configuration); + this.emitOldAttributes = httpSemanticConvention.HasFlag(HttpSemanticConvention.Old); + this.emitNewAttributes = httpSemanticConvention.HasFlag(HttpSemanticConvention.New); + } + + /// + /// Gets or sets a value indicating whether or not the should add the names of commands as the tag. Default + /// value: . + /// + /// + /// SetDbStatementForStoredProcedure is only supported on .NET + /// and .NET Core runtimes. + /// + public bool SetDbStatementForStoredProcedure { get; set; } = true; + + /// + /// Gets or sets a value indicating whether or not the should add the text of commands as + /// the tag. + /// Default value: . + /// + /// + /// + /// WARNING: SetDbStatementForText will capture the raw + /// CommandText. Make sure your CommandText property never + /// contains any sensitive data. + /// + /// SetDbStatementForText is supported on all runtimes. + /// + /// On .NET and .NET Core SetDbStatementForText only applies to + /// SqlCommands with . + /// On .NET Framework SetDbStatementForText applies to all + /// SqlCommands regardless of . + /// + /// When using System.Data.SqlClient use + /// SetDbStatementForText to capture StoredProcedure command + /// names. + /// When using Microsoft.Data.SqlClient use + /// SetDbStatementForText to capture Text, StoredProcedure, and all + /// other command text. + /// + /// + /// + /// + public bool SetDbStatementForText { get; set; } + + /// + /// Gets or sets a value indicating whether or not the should parse the DataSource on a + /// SqlConnection into server name, instance name, and/or port + /// connection-level attribute tags. Default value: . + /// + /// + /// + /// EnableConnectionLevelAttributes is supported on all runtimes. + /// + /// + /// The default behavior is to set the SqlConnection DataSource as the tag. + /// If enabled, SqlConnection DataSource will be parsed and the server name will be sent as the + /// or tag, + /// the instance name will be sent as the tag, + /// and the port will be sent as the tag if it is not 1433 (the default port). + /// + /// + /// If the environment variable OTEL_SEMCONV_STABILITY_OPT_IN is set to "http", the newer Semantic Convention v1.21.0 Attributes will be emitted. + /// SqlConnection DataSource will be parsed and the server name will be sent as the + /// or tag, + /// the instance name will be sent as the tag, + /// and the port will be sent as the tag if it is not 1433 (the default port). + /// + /// + public bool EnableConnectionLevelAttributes { get; set; } + + /// + /// Gets or sets an action to enrich an with the + /// raw SqlCommand object. + /// + /// + /// Enrich is only executed on .NET and .NET Core + /// runtimes. + /// The parameters passed to the enrich action are: + /// + /// The being enriched. + /// The name of the event. Currently only "OnCustom" is + /// used but more events may be added in the future. + /// The raw SqlCommand object from which additional + /// information can be extracted to enrich the . + /// + /// + public Action Enrich { get; set; } + + /// + /// Gets or sets a filter function that determines whether or not to + /// collect telemetry about a command. + /// + /// + /// Filter is only executed on .NET and .NET Core + /// runtimes. + /// Notes: + /// + /// The first parameter passed to the filter function is the raw + /// SqlCommand object for the command being executed. + /// The return value for the filter function is interpreted as: + /// + /// If filter returns , the command is + /// collected. + /// If filter returns or throws an + /// exception the command is NOT collected. + /// + /// + /// + public Func Filter { get; set; } + + /// + /// Gets or sets a value indicating whether the exception will be + /// recorded as or not. Default value: . + /// + /// + /// RecordException is only supported on .NET and .NET Core + /// runtimes. + /// For specification details see: . + /// + public bool RecordException { get; set; } + + internal static SqlConnectionDetails ParseDataSource(string dataSource) + { + Match match = DataSourceRegex.Match(dataSource); + + string serverHostName = match.Groups[2].Value; + string serverIpAddress = null; + + string instanceName; + + var uriHostNameType = Uri.CheckHostName(serverHostName); + if (uriHostNameType == UriHostNameType.IPv4 || uriHostNameType == UriHostNameType.IPv6) + { + serverIpAddress = serverHostName; + serverHostName = null; + } + + string maybeProtocol = match.Groups[1].Value; + bool isNamedPipe = maybeProtocol.Length > 0 && + maybeProtocol.StartsWith("np", StringComparison.OrdinalIgnoreCase); + + if (isNamedPipe) + { + string pipeName = match.Groups[3].Value; + if (pipeName.Length > 0) + { + var namedInstancePipeMatch = NamedPipeRegex.Match(pipeName); + if (namedInstancePipeMatch.Success) + { + instanceName = namedInstancePipeMatch.Groups[1].Value; + return new SqlConnectionDetails + { + ServerHostName = serverHostName, + ServerIpAddress = serverIpAddress, + InstanceName = instanceName, + Port = null, + }; + } + } + + return new SqlConnectionDetails + { + ServerHostName = serverHostName, + ServerIpAddress = serverIpAddress, + InstanceName = null, + Port = null, + }; + } + + string port; + if (match.Groups[4].Length > 0) + { + instanceName = match.Groups[3].Value; + port = match.Groups[4].Value; + if (port == "1433") + { + port = null; + } + } + else if (int.TryParse(match.Groups[3].Value, out int parsedPort)) + { + port = parsedPort == 1433 ? null : match.Groups[3].Value; + instanceName = null; + } + else + { + instanceName = match.Groups[3].Value; + + if (string.IsNullOrEmpty(instanceName)) + { + instanceName = null; + } + + port = null; + } + + return new SqlConnectionDetails + { + ServerHostName = serverHostName, + ServerIpAddress = serverIpAddress, + InstanceName = instanceName, + Port = port, + }; + } + + internal void AddConnectionLevelDetailsToActivity(string dataSource, Activity sqlActivity) + { + if (!this.EnableConnectionLevelAttributes) + { + sqlActivity.SetTag(SemanticConventions.AttributePeerService, dataSource); + } + else + { + if (!ConnectionDetailCache.TryGetValue(dataSource, out SqlConnectionDetails connectionDetails)) + { + connectionDetails = ParseDataSource(dataSource); + ConnectionDetailCache.TryAdd(dataSource, connectionDetails); + } + + if (!string.IsNullOrEmpty(connectionDetails.InstanceName)) + { + sqlActivity.SetTag(SemanticConventions.AttributeDbMsSqlInstanceName, connectionDetails.InstanceName); + } + + if (this.emitOldAttributes) + { + if (!string.IsNullOrEmpty(connectionDetails.ServerHostName)) + { + sqlActivity.SetTag(SemanticConventions.AttributeNetPeerName, connectionDetails.ServerHostName); + } + else + { + sqlActivity.SetTag(SemanticConventions.AttributeNetPeerIp, connectionDetails.ServerIpAddress); + } + + if (!string.IsNullOrEmpty(connectionDetails.Port)) + { + sqlActivity.SetTag(SemanticConventions.AttributeNetPeerPort, connectionDetails.Port); + } + } + + // see the spec https://github.com/open-telemetry/semantic-conventions/blob/v1.21.0/docs/database/database-spans.md + if (this.emitNewAttributes) + { + if (!string.IsNullOrEmpty(connectionDetails.ServerHostName)) + { + sqlActivity.SetTag(SemanticConventions.AttributeServerAddress, connectionDetails.ServerHostName); + } + else + { + sqlActivity.SetTag(SemanticConventions.AttributeServerSocketAddress, connectionDetails.ServerIpAddress); + } + + if (!string.IsNullOrEmpty(connectionDetails.Port)) + { + // TODO: Should we continue to emit this if the default port (1433) is being used? + sqlActivity.SetTag(SemanticConventions.AttributeServerPort, connectionDetails.Port); + } + } + } + } + + internal sealed class SqlConnectionDetails + { + public string ServerHostName { get; set; } + + public string ServerIpAddress { get; set; } + + public string InstanceName { get; set; } + + public string Port { get; set; } + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.SqlClient/SqlClient_TracerProviderBuilderExtensions.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.SqlClient/SqlClient_TracerProviderBuilderExtensions.cs new file mode 100644 index 000000000000..3fa965c2fecd --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/OpenTelemetry.Instrumentation.SqlClient/SqlClient_TracerProviderBuilderExtensions.cs @@ -0,0 +1,88 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Options; +using OpenTelemetry.Instrumentation.SqlClient; +using OpenTelemetry.Instrumentation.SqlClient.Implementation; +using OpenTelemetry.Internal; + +namespace OpenTelemetry.Trace +{ + /// + /// Extension methods to simplify registering of dependency instrumentation. + /// + internal static class SqlClient_TracerProviderBuilderExtensions + { + /// + /// Enables SqlClient instrumentation. + /// + /// being configured. + /// The instance of to chain the calls. + public static TracerProviderBuilder AddSqlClientInstrumentation(this TracerProviderBuilder builder) + => AddSqlClientInstrumentation(builder, name: null, configureSqlClientInstrumentationOptions: null); + + /// + /// Enables SqlClient instrumentation. + /// + /// being configured. + /// Callback action for configuring . + /// The instance of to chain the calls. + public static TracerProviderBuilder AddSqlClientInstrumentation( + this TracerProviderBuilder builder, + Action configureSqlClientInstrumentationOptions) + => AddSqlClientInstrumentation(builder, name: null, configureSqlClientInstrumentationOptions); + + /// + /// Enables SqlClient instrumentation. + /// + /// being configured. + /// Name which is used when retrieving options. + /// Callback action for configuring . + /// The instance of to chain the calls. + public static TracerProviderBuilder AddSqlClientInstrumentation( + this TracerProviderBuilder builder, + string name, + Action configureSqlClientInstrumentationOptions) + { + Guard.ThrowIfNull(builder); + + name ??= Options.DefaultName; + + builder.ConfigureServices(services => + { + if (configureSqlClientInstrumentationOptions != null) + { + services.Configure(name, configureSqlClientInstrumentationOptions); + } + + services.RegisterOptionsFactory(configuration => new SqlClientInstrumentationOptions(configuration)); + }); + + builder.AddInstrumentation(sp => + { + var sqlOptions = sp.GetRequiredService>().Get(name); + + return new SqlClientInstrumentation(sqlOptions); + }); + + builder.AddSource(SqlActivitySourceHelper.ActivitySourceName); + + return builder; + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/ActivityHelperExtensions.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/ActivityHelperExtensions.cs new file mode 100644 index 000000000000..023895dade1d --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/ActivityHelperExtensions.cs @@ -0,0 +1,126 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System.Diagnostics; +using System.Runtime.CompilerServices; +using OpenTelemetry.Internal; + +namespace OpenTelemetry.Trace; + +/// +/// Extension methods on Activity. +/// +internal static class ActivityHelperExtensions +{ + /// + /// Gets the status of activity execution. + /// Activity class in .NET does not support 'Status'. + /// This extension provides a workaround to retrieve Status from special tags with key name otel.status_code and otel.status_description. + /// + /// Activity instance. + /// . + /// Status description. + /// if was found on the supplied Activity. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool TryGetStatus(this Activity activity, out StatusCode statusCode, out string statusDescription) + { + Debug.Assert(activity != null, "Activity should not be null"); + + bool foundStatusCode = false; + statusCode = default; + statusDescription = null; + + foreach (ref readonly var tag in activity.EnumerateTagObjects()) + { + switch (tag.Key) + { + case SpanAttributeConstants.StatusCodeKey: + foundStatusCode = StatusHelper.TryGetStatusCodeForTagValue(tag.Value as string, out statusCode); + if (!foundStatusCode) + { + // If status code was found but turned out to be invalid give up immediately. + return false; + } + + break; + case SpanAttributeConstants.StatusDescriptionKey: + statusDescription = tag.Value as string; + break; + default: + continue; + } + + if (foundStatusCode && statusDescription != null) + { + // If we found a status code and a description we break enumeration because our work is done. + break; + } + } + + return foundStatusCode; + } + + /// + /// Gets the value of a specific tag on an . + /// + /// Activity instance. + /// Case-sensitive tag name to retrieve. + /// Tag value or null if a match was not found. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static object GetTagValue(this Activity activity, string tagName) + { + Debug.Assert(activity != null, "Activity should not be null"); + + foreach (ref readonly var tag in activity.EnumerateTagObjects()) + { + if (tag.Key == tagName) + { + return tag.Value; + } + } + + return null; + } + + /// + /// Checks if the user provided tag name is the first tag of the and retrieves the tag value. + /// + /// Activity instance. + /// Tag name. + /// Tag value. + /// if the first tag of the supplied Activity matches the user provide tag name. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool TryCheckFirstTag(this Activity activity, string tagName, out object tagValue) + { + Debug.Assert(activity != null, "Activity should not be null"); + + var enumerator = activity.EnumerateTagObjects(); + + if (enumerator.MoveNext()) + { + ref readonly var tag = ref enumerator.Current; + + if (tag.Key == tagName) + { + tagValue = tag.Value; + return true; + } + } + + tagValue = null; + return false; + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/ActivityInstrumentationHelper.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/ActivityInstrumentationHelper.cs new file mode 100644 index 000000000000..06c6d90540b7 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/ActivityInstrumentationHelper.cs @@ -0,0 +1,47 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using System.Diagnostics; +using System.Linq.Expressions; +using System.Reflection; +#pragma warning restore IDE0005 + +namespace OpenTelemetry.Instrumentation; + +internal static class ActivityInstrumentationHelper +{ + internal static readonly Action SetKindProperty = CreateActivityKindSetter(); + internal static readonly Action SetActivitySourceProperty = CreateActivitySourceSetter(); + + private static Action CreateActivitySourceSetter() + { + ParameterExpression instance = Expression.Parameter(typeof(Activity), "instance"); + ParameterExpression propertyValue = Expression.Parameter(typeof(ActivitySource), "propertyValue"); + PropertyInfo sourcePropertyInfo = typeof(Activity).GetProperty("Source"); + var body = Expression.Assign(Expression.Property(instance, sourcePropertyInfo), propertyValue); + return Expression.Lambda>(body, instance, propertyValue).Compile(); + } + + private static Action CreateActivityKindSetter() + { + ParameterExpression instance = Expression.Parameter(typeof(Activity), "instance"); + ParameterExpression propertyValue = Expression.Parameter(typeof(ActivityKind), "propertyValue"); + PropertyInfo kindPropertyInfo = typeof(Activity).GetProperty("Kind"); + var body = Expression.Assign(Expression.Property(instance, kindPropertyInfo), propertyValue); + return Expression.Lambda>(body, instance, propertyValue).Compile(); + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/DiagnosticSourceInstrumentation/DiagnosticSourceListener.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/DiagnosticSourceInstrumentation/DiagnosticSourceListener.cs new file mode 100644 index 000000000000..b61ad64c724a --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/DiagnosticSourceInstrumentation/DiagnosticSourceListener.cs @@ -0,0 +1,61 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using OpenTelemetry.Internal; +#pragma warning restore IDE0005 + +namespace OpenTelemetry.Instrumentation +{ + internal sealed class DiagnosticSourceListener : IObserver> + { + private readonly ListenerHandler handler; + + public DiagnosticSourceListener(ListenerHandler handler) + { + Guard.ThrowIfNull(handler); + + this.handler = handler; + } + + public void OnCompleted() + { + } + + public void OnError(Exception error) + { + } + + public void OnNext(KeyValuePair value) + { + if (!this.handler.SupportsNullActivity && Activity.Current == null) + { + return; + } + + try + { + this.handler.OnEventWritten(value.Key, value.Value); + } + catch (Exception ex) + { + InstrumentationEventSource.Log.UnknownErrorProcessingEvent(this.handler?.SourceName, value.Key, ex); + } + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/DiagnosticSourceInstrumentation/DiagnosticSourceSubscriber.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/DiagnosticSourceInstrumentation/DiagnosticSourceSubscriber.cs new file mode 100644 index 000000000000..e0e443fdfe44 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/DiagnosticSourceInstrumentation/DiagnosticSourceSubscriber.cs @@ -0,0 +1,116 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Threading; +using OpenTelemetry.Internal; + +namespace OpenTelemetry.Instrumentation +{ + internal sealed class DiagnosticSourceSubscriber : IDisposable, IObserver + { + private readonly List listenerSubscriptions; + private readonly Func handlerFactory; + private readonly Func diagnosticSourceFilter; + private readonly Func isEnabledFilter; + private long disposed; + private IDisposable allSourcesSubscription; + + public DiagnosticSourceSubscriber( + ListenerHandler handler, + Func isEnabledFilter) + : this(_ => handler, value => handler.SourceName == value.Name, isEnabledFilter) + { + } + + public DiagnosticSourceSubscriber( + Func handlerFactory, + Func diagnosticSourceFilter, + Func isEnabledFilter) + { + Guard.ThrowIfNull(handlerFactory); + + this.listenerSubscriptions = new List(); + this.handlerFactory = handlerFactory; + this.diagnosticSourceFilter = diagnosticSourceFilter; + this.isEnabledFilter = isEnabledFilter; + } + + public void Subscribe() + { + if (this.allSourcesSubscription == null) + { + this.allSourcesSubscription = DiagnosticListener.AllListeners.Subscribe(this); + } + } + + public void OnNext(DiagnosticListener value) + { + if ((Interlocked.Read(ref this.disposed) == 0) && + this.diagnosticSourceFilter(value)) + { + var handler = this.handlerFactory(value.Name); + var listener = new DiagnosticSourceListener(handler); + var subscription = this.isEnabledFilter == null ? + value.Subscribe(listener) : + value.Subscribe(listener, this.isEnabledFilter); + + lock (this.listenerSubscriptions) + { + this.listenerSubscriptions.Add(subscription); + } + } + } + + public void OnCompleted() + { + } + + public void OnError(Exception error) + { + } + + /// + public void Dispose() + { + this.Dispose(true); + GC.SuppressFinalize(this); + } + + private void Dispose(bool disposing) + { + if (Interlocked.CompareExchange(ref this.disposed, 1, 0) == 1) + { + return; + } + + lock (this.listenerSubscriptions) + { + foreach (var listenerSubscription in this.listenerSubscriptions) + { + listenerSubscription?.Dispose(); + } + + this.listenerSubscriptions.Clear(); + } + + this.allSourcesSubscription?.Dispose(); + this.allSourcesSubscription = null; + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/DiagnosticSourceInstrumentation/InstrumentationEventSource.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/DiagnosticSourceInstrumentation/InstrumentationEventSource.cs new file mode 100644 index 000000000000..b18f57b7336b --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/DiagnosticSourceInstrumentation/InstrumentationEventSource.cs @@ -0,0 +1,52 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using System.Diagnostics.Tracing; +using OpenTelemetry.Internal; +#pragma warning restore IDE0005 + +namespace OpenTelemetry.Instrumentation; + +/// +/// EventSource events emitted from the project. +/// +[EventSource(Name = "OpenTelemetry-Instrumentation")] +internal sealed class InstrumentationEventSource : EventSource +{ + public static InstrumentationEventSource Log = new(); + + [Event(1, Message = "Current Activity is NULL in the '{0}' callback. Activity will not be recorded.", Level = EventLevel.Warning)] + public void NullActivity(string eventName) + { + this.WriteEvent(1, eventName); + } + + [NonEvent] + public void UnknownErrorProcessingEvent(string handlerName, string eventName, Exception ex) + { + if (this.IsEnabled(EventLevel.Error, EventKeywords.All)) + { + this.UnknownErrorProcessingEvent(handlerName, eventName, ex.ToInvariantString()); + } + } + + [Event(2, Message = "Unknown error processing event '{1}' from handler '{0}', Exception: {2}", Level = EventLevel.Error)] + public void UnknownErrorProcessingEvent(string handlerName, string eventName, string ex) + { + this.WriteEvent(2, handlerName, eventName, ex); + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/DiagnosticSourceInstrumentation/ListenerHandler.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/DiagnosticSourceInstrumentation/ListenerHandler.cs new file mode 100644 index 000000000000..c41fb22015b9 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/DiagnosticSourceInstrumentation/ListenerHandler.cs @@ -0,0 +1,52 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +using System.Diagnostics; + +namespace OpenTelemetry.Instrumentation; + +/// +/// ListenerHandler base class. +/// +internal abstract class ListenerHandler +{ + /// + /// Initializes a new instance of the class. + /// + /// The name of the . + public ListenerHandler(string sourceName) + { + this.SourceName = sourceName; + } + + /// + /// Gets the name of the . + /// + public string SourceName { get; } + + /// + /// Gets a value indicating whether the supports NULL . + /// + public virtual bool SupportsNullActivity { get; } + + /// + /// Method called for an event which does not have 'Start', 'Stop' or 'Exception' as suffix. + /// + /// Custom name. + /// An object that represent the value being passed as a payload for the event. + public virtual void OnEventWritten(string name, object payload) + { + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/DiagnosticSourceInstrumentation/PropertyFetcher.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/DiagnosticSourceInstrumentation/PropertyFetcher.cs new file mode 100644 index 000000000000..1160902570a9 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/DiagnosticSourceInstrumentation/PropertyFetcher.cs @@ -0,0 +1,157 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using System.Linq; +using System.Reflection; +using OpenTelemetry.Internal; +#pragma warning restore IDE0005 + +namespace OpenTelemetry.Instrumentation; + +/// +/// PropertyFetcher fetches a property from an object. +/// +/// The type of the property being fetched. +internal sealed class PropertyFetcher +{ + private readonly string propertyName; + private PropertyFetch innerFetcher; + + /// + /// Initializes a new instance of the class. + /// + /// Property name to fetch. + public PropertyFetcher(string propertyName) + { + this.propertyName = propertyName; + } + + /// + /// Fetch the property from the object. + /// + /// Object to be fetched. + /// Property fetched. + public T Fetch(object obj) + { + Guard.ThrowIfNull(obj); + + if (!this.TryFetch(obj, out T value, true)) + { + throw new ArgumentException($"Unable to fetch property: '{nameof(obj)}'", nameof(obj)); + } + + return value; + } + + /// + /// Try to fetch the property from the object. + /// + /// Object to be fetched. + /// Fetched value. + /// Set this to if we know is not . + /// if the property was fetched. + public bool TryFetch(object obj, out T value, bool skipObjNullCheck = false) + { + if (!skipObjNullCheck && obj == null) + { + value = default; + return false; + } + + if (this.innerFetcher == null) + { + this.innerFetcher = PropertyFetch.Create(obj.GetType().GetTypeInfo(), this.propertyName); + } + + if (this.innerFetcher == null) + { + value = default; + return false; + } + + return this.innerFetcher.TryFetch(obj, out value); + } + + // see https://github.com/dotnet/corefx/blob/master/src/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/DiagnosticSourceEventSource.cs + private class PropertyFetch + { + public static PropertyFetch Create(TypeInfo type, string propertyName) + { + var property = type.DeclaredProperties.FirstOrDefault(p => string.Equals(p.Name, propertyName, StringComparison.OrdinalIgnoreCase)); + if (property == null) + { + property = type.GetProperty(propertyName); + } + + return CreateFetcherForProperty(property); + + static PropertyFetch CreateFetcherForProperty(PropertyInfo propertyInfo) + { + if (propertyInfo == null || !typeof(T).IsAssignableFrom(propertyInfo.PropertyType)) + { + // returns null and wait for a valid payload to arrive. + return null; + } + + var typedPropertyFetcher = typeof(TypedPropertyFetch<,>); + var instantiatedTypedPropertyFetcher = typedPropertyFetcher.MakeGenericType( + typeof(T), propertyInfo.DeclaringType, propertyInfo.PropertyType); + return (PropertyFetch)Activator.CreateInstance(instantiatedTypedPropertyFetcher, propertyInfo); + } + } + + public virtual bool TryFetch(object obj, out T value) + { + value = default; + return false; + } + + private sealed class TypedPropertyFetch : PropertyFetch + where TDeclaredProperty : T + { + private readonly string propertyName; + private readonly Func propertyFetch; + + private PropertyFetch innerFetcher; + + public TypedPropertyFetch(PropertyInfo property) + { + this.propertyName = property.Name; + this.propertyFetch = (Func)property.GetMethod.CreateDelegate(typeof(Func)); + } + + public override bool TryFetch(object obj, out T value) + { + if (obj is TDeclaredObject o) + { + value = this.propertyFetch(o); + return true; + } + + this.innerFetcher ??= Create(obj.GetType().GetTypeInfo(), this.propertyName); + + if (this.innerFetcher == null) + { + value = default; + return false; + } + + return this.innerFetcher.TryFetch(obj, out value); + } + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/EnvironmentVariables/EnvironmentVariablesConfigurationProvider.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/EnvironmentVariables/EnvironmentVariablesConfigurationProvider.cs new file mode 100644 index 000000000000..8d58d6418020 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/EnvironmentVariables/EnvironmentVariablesConfigurationProvider.cs @@ -0,0 +1,85 @@ +// (Turns off StyleCop analysis in this file.) +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#nullable enable + +using System; +using System.Collections; +using System.Collections.Generic; + +namespace Microsoft.Extensions.Configuration.EnvironmentVariables +{ + /// + /// An environment variable based . + /// + internal sealed class EnvironmentVariablesConfigurationProvider : ConfigurationProvider + { + private readonly string _prefix; + private readonly string _normalizedPrefix; + + /// + /// Initializes a new instance. + /// + public EnvironmentVariablesConfigurationProvider() + { + _prefix = string.Empty; + _normalizedPrefix = string.Empty; + } + + /// + /// Initializes a new instance with the specified prefix. + /// + /// A prefix used to filter the environment variables. + public EnvironmentVariablesConfigurationProvider(string? prefix) + { + _prefix = prefix ?? string.Empty; + _normalizedPrefix = Normalize(_prefix); + } + + /// + /// Loads the environment variables. + /// + public override void Load() => + Load(Environment.GetEnvironmentVariables()); + + /// + /// Generates a string representing this provider name and relevant details. + /// + /// The configuration name. + public override string ToString() + => $"{GetType().Name} Prefix: '{_prefix}'"; + + internal void Load(IDictionary envVariables) + { + var data = new Dictionary(StringComparer.OrdinalIgnoreCase); + + IDictionaryEnumerator e = envVariables.GetEnumerator(); + try + { + while (e.MoveNext()) + { + string key = (string)e.Entry.Key; + string? value = (string?)e.Entry.Value; + AddIfNormalizedKeyMatchesPrefix(data, Normalize(key), value); + } + } + finally + { + (e as IDisposable)?.Dispose(); + } + + Data = data; + } + + private void AddIfNormalizedKeyMatchesPrefix(Dictionary data, string normalizedKey, string? value) + { + if (normalizedKey.StartsWith(_normalizedPrefix, StringComparison.OrdinalIgnoreCase)) + { + data[normalizedKey.Substring(_normalizedPrefix.Length)] = value; + } + } + + private static string Normalize(string key) => key.Replace("__", ConfigurationPath.KeyDelimiter); + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/EnvironmentVariables/EnvironmentVariablesConfigurationSource.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/EnvironmentVariables/EnvironmentVariablesConfigurationSource.cs new file mode 100644 index 000000000000..2785b2174756 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/EnvironmentVariables/EnvironmentVariablesConfigurationSource.cs @@ -0,0 +1,29 @@ +// (Turns off StyleCop analysis in this file.) +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#nullable enable + +namespace Microsoft.Extensions.Configuration.EnvironmentVariables +{ + /// + /// Represents environment variables as an . + /// + internal sealed class EnvironmentVariablesConfigurationSource : IConfigurationSource + { + /// + /// A prefix used to filter environment variables. + /// + public string? Prefix { get; set; } + + /// + /// Builds the for this source. + /// + /// The . + /// A + public IConfigurationProvider Build(IConfigurationBuilder builder) + { + return new EnvironmentVariablesConfigurationProvider(Prefix); + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/EnvironmentVariables/EnvironmentVariablesExtensions.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/EnvironmentVariables/EnvironmentVariablesExtensions.cs new file mode 100644 index 000000000000..5b97e90ce774 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/EnvironmentVariables/EnvironmentVariablesExtensions.cs @@ -0,0 +1,52 @@ +// (Turns off StyleCop analysis in this file.) +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +#nullable enable + +using System; +using Microsoft.Extensions.Configuration.EnvironmentVariables; + +namespace Microsoft.Extensions.Configuration +{ + /// + /// Extension methods for registering with . + /// + internal static class EnvironmentVariablesExtensions + { + /// + /// Adds an that reads configuration values from environment variables. + /// + /// The to add to. + /// The . + public static IConfigurationBuilder AddEnvironmentVariables(this IConfigurationBuilder configurationBuilder) + { + configurationBuilder.Add(new EnvironmentVariablesConfigurationSource()); + return configurationBuilder; + } + + /// + /// Adds an that reads configuration values from environment variables + /// with a specified prefix. + /// + /// The to add to. + /// The prefix that environment variable names must start with. The prefix will be removed from the environment variable names. + /// The . + public static IConfigurationBuilder AddEnvironmentVariables( + this IConfigurationBuilder configurationBuilder, + string? prefix) + { + configurationBuilder.Add(new EnvironmentVariablesConfigurationSource { Prefix = prefix }); + return configurationBuilder; + } + + /// + /// Adds an that reads configuration values from environment variables. + /// + /// The to add to. + /// Configures the source. + /// The . + public static IConfigurationBuilder AddEnvironmentVariables(this IConfigurationBuilder builder, Action? configureSource) + => builder.Add(configureSource); + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/ExceptionExtensions.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/ExceptionExtensions.cs new file mode 100644 index 000000000000..2f6cf5adbefc --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/ExceptionExtensions.cs @@ -0,0 +1,47 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#nullable enable + +using System; +using System.Globalization; +using System.Threading; + +namespace OpenTelemetry.Internal; + +internal static class ExceptionExtensions +{ + /// + /// Returns a culture-independent string representation of the given object, + /// appropriate for diagnostics tracing. + /// + /// Exception to convert to string. + /// Exception as string with no culture. + public static string ToInvariantString(this Exception exception) + { + var originalUICulture = Thread.CurrentThread.CurrentUICulture; + + try + { + Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture; + return exception.ToString(); + } + finally + { + Thread.CurrentThread.CurrentUICulture = originalUICulture; + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/Guard.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/Guard.cs new file mode 100644 index 000000000000..f5cdfc5317e9 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/Guard.cs @@ -0,0 +1,217 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#nullable enable + +using System; +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Globalization; +using System.Runtime.CompilerServices; +using System.Threading; + +#pragma warning disable SA1402 // File may only contain a single type +#pragma warning disable SA1403 // File may only contain a single namespace +#pragma warning disable SA1649 // File name should match first type name + +#if !NET6_0_OR_GREATER +namespace System.Runtime.CompilerServices +{ + /// Allows capturing of the expressions passed to a method. + [AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)] + internal sealed class CallerArgumentExpressionAttribute : Attribute + { + public CallerArgumentExpressionAttribute(string parameterName) + { + this.ParameterName = parameterName; + } + + public string ParameterName { get; } + } +} +#endif + +#if !NET6_0_OR_GREATER && !NETSTANDARD2_1_OR_GREATER +namespace System.Diagnostics.CodeAnalysis +{ + /// Specifies that an output is not even if + /// the corresponding type allows it. Specifies that an input argument was + /// not when the call returns. + [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)] + internal sealed class NotNullAttribute : Attribute + { + } +} +#endif + +namespace OpenTelemetry.Internal +{ + /// + /// Methods for guarding against exception throwing values. + /// + internal static class Guard + { + /// + /// Throw an exception if the value is null. + /// + /// The value to check. + /// The parameter name to use in the thrown exception. + [DebuggerHidden] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void ThrowIfNull([NotNull] object? value, [CallerArgumentExpression("value")] string? paramName = null) + { + if (value is null) + { + throw new ArgumentNullException(paramName, "Must not be null"); + } + } + + /// + /// Throw an exception if the value is null or empty. + /// + /// The value to check. + /// The parameter name to use in the thrown exception. + [DebuggerHidden] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void ThrowIfNullOrEmpty([NotNull] string? value, [CallerArgumentExpression("value")] string? paramName = null) +#pragma warning disable CS8777 // Parameter must have a non-null value when exiting. + { + if (string.IsNullOrEmpty(value)) + { + throw new ArgumentException("Must not be null or empty", paramName); + } + } +#pragma warning restore CS8777 // Parameter must have a non-null value when exiting. + + /// + /// Throw an exception if the value is null or whitespace. + /// + /// The value to check. + /// The parameter name to use in the thrown exception. + [DebuggerHidden] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void ThrowIfNullOrWhitespace([NotNull] string? value, [CallerArgumentExpression("value")] string? paramName = null) +#pragma warning disable CS8777 // Parameter must have a non-null value when exiting. + { + if (string.IsNullOrWhiteSpace(value)) + { + throw new ArgumentException("Must not be null or whitespace", paramName); + } + } +#pragma warning restore CS8777 // Parameter must have a non-null value when exiting. + + /// + /// Throw an exception if the value is zero. + /// + /// The value to check. + /// The message to use in the thrown exception. + /// The parameter name to use in the thrown exception. + [DebuggerHidden] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void ThrowIfZero(int value, string message = "Must not be zero", [CallerArgumentExpression("value")] string? paramName = null) + { + if (value == 0) + { + throw new ArgumentException(message, paramName); + } + } + + /// + /// Throw an exception if the value is not considered a valid timeout. + /// + /// The value to check. + /// The parameter name to use in the thrown exception. + [DebuggerHidden] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void ThrowIfInvalidTimeout(int value, [CallerArgumentExpression("value")] string? paramName = null) + { + ThrowIfOutOfRange(value, paramName, min: Timeout.Infinite, message: $"Must be non-negative or '{nameof(Timeout)}.{nameof(Timeout.Infinite)}'"); + } + + /// + /// Throw an exception if the value is not within the given range. + /// + /// The value to check. + /// The parameter name to use in the thrown exception. + /// The inclusive lower bound. + /// The inclusive upper bound. + /// The name of the lower bound. + /// The name of the upper bound. + /// An optional custom message to use in the thrown exception. + [DebuggerHidden] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void ThrowIfOutOfRange(int value, [CallerArgumentExpression("value")] string? paramName = null, int min = int.MinValue, int max = int.MaxValue, string? minName = null, string? maxName = null, string? message = null) + { + Range(value, paramName, min, max, minName, maxName, message); + } + + /// + /// Throw an exception if the value is not within the given range. + /// + /// The value to check. + /// The parameter name to use in the thrown exception. + /// The inclusive lower bound. + /// The inclusive upper bound. + /// The name of the lower bound. + /// The name of the upper bound. + /// An optional custom message to use in the thrown exception. + [DebuggerHidden] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void ThrowIfOutOfRange(double value, [CallerArgumentExpression("value")] string? paramName = null, double min = double.MinValue, double max = double.MaxValue, string? minName = null, string? maxName = null, string? message = null) + { + Range(value, paramName, min, max, minName, maxName, message); + } + + /// + /// Throw an exception if the value is not of the expected type. + /// + /// The value to check. + /// The parameter name to use in the thrown exception. + /// The type attempted to convert to. + /// The value casted to the specified type. + [DebuggerHidden] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static T ThrowIfNotOfType([NotNull] object? value, [CallerArgumentExpression("value")] string? paramName = null) + { + if (value is not T result) + { + throw new InvalidCastException($"Cannot cast '{paramName}' from '{value?.GetType().ToString() ?? "null"}' to '{typeof(T)}'"); + } + + return result; + } + + [DebuggerHidden] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static void Range(T value, string? paramName, T min, T max, string? minName, string? maxName, string? message) + where T : IComparable + { + if (value.CompareTo(min) < 0 || value.CompareTo(max) > 0) + { + var minMessage = minName != null ? $": {minName}" : string.Empty; + var maxMessage = maxName != null ? $": {maxName}" : string.Empty; + var exMessage = message ?? string.Format( + CultureInfo.InvariantCulture, + "Must be in the range: [{0}{1}, {2}{3}]", + min, + minMessage, + max, + maxMessage); + throw new ArgumentOutOfRangeException(paramName, value, exMessage); + } + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/HttpSemanticConventionHelper.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/HttpSemanticConventionHelper.cs new file mode 100644 index 000000000000..b27149a318f3 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/HttpSemanticConventionHelper.cs @@ -0,0 +1,76 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#nullable enable + +using System; +using System.Diagnostics; +using Microsoft.Extensions.Configuration; + +namespace OpenTelemetry.Internal; + +/// +/// Helper class for Http Semantic Conventions. +/// +/// +/// Due to a breaking change in the semantic convention, affected instrumentation libraries +/// must inspect an environment variable to determine which attributes to emit. +/// This is expected to be removed when the instrumentation libraries reach Stable. +/// . +/// +internal static class HttpSemanticConventionHelper +{ + public const string SemanticConventionOptInKeyName = "OTEL_SEMCONV_STABILITY_OPT_IN"; + + [Flags] + public enum HttpSemanticConvention + { + /// + /// Instructs an instrumentation library to emit the old experimental HTTP attributes. + /// + Old = 0x1, + + /// + /// Instructs an instrumentation library to emit the new, v1.21.0 Http attributes. + /// + New = 0x2, + + /// + /// Instructs an instrumentation library to emit both the old and new attributes. + /// + Dupe = Old | New, + } + + public static HttpSemanticConvention GetSemanticConventionOptIn(IConfiguration configuration) + { + Debug.Assert(configuration != null, "configuration was null"); + + try + { + var envVarValue = configuration![SemanticConventionOptInKeyName]; + return envVarValue?.ToLowerInvariant() switch + { + "http" => HttpSemanticConvention.New, + "http/dup" => HttpSemanticConvention.Dupe, + _ => HttpSemanticConvention.Old, + }; + } + catch + { + return HttpSemanticConvention.Old; + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/MathHelper.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/MathHelper.cs new file mode 100644 index 000000000000..91670f60daad --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/MathHelper.cs @@ -0,0 +1,145 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System.Diagnostics; +#if NET6_0_OR_GREATER +using System.Numerics; +#endif +using System.Runtime.CompilerServices; + +namespace OpenTelemetry.Internal; + +internal static class MathHelper +{ + // https://en.wikipedia.org/wiki/Leading_zero + private static readonly byte[] LeadingZeroLookupTable = new byte[] + { + 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + }; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int LeadingZero8(byte value) + { + return LeadingZeroLookupTable[value]; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int LeadingZero16(short value) + { + unchecked + { + var high8 = (byte)(value >> 8); + + if (high8 != 0) + { + return LeadingZero8(high8); + } + + return LeadingZero8((byte)value) + 8; + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int LeadingZero32(int value) + { + unchecked + { + var high16 = (short)(value >> 16); + + if (high16 != 0) + { + return LeadingZero16(high16); + } + + return LeadingZero16((short)value) + 16; + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int LeadingZero64(long value) + { +#if NET6_0_OR_GREATER + return BitOperations.LeadingZeroCount((ulong)value); +#else + unchecked + { + var high32 = (int)(value >> 32); + + if (high32 != 0) + { + return LeadingZero32(high32); + } + + return LeadingZero32((int)value) + 32; + } +#endif + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int PositiveModulo32(int value, int divisor) + { + Debug.Assert(divisor > 0, $"{nameof(divisor)} must be a positive integer."); + + value %= divisor; + + if (value < 0) + { + value += divisor; + } + + return value; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static long PositiveModulo64(long value, long divisor) + { + Debug.Assert(divisor > 0, $"{nameof(divisor)} must be a positive integer."); + + value %= divisor; + + if (value < 0) + { + value += divisor; + } + + return value; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool IsFinite(double value) + { +#if NET6_0_OR_GREATER + return double.IsFinite(value); +#else + return !double.IsInfinity(value) && !double.IsNaN(value); +#endif + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/Options/ConfigurationExtensions.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/Options/ConfigurationExtensions.cs new file mode 100644 index 000000000000..b0ecf229c377 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/Options/ConfigurationExtensions.cs @@ -0,0 +1,164 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#nullable enable + +using System; +using System.Diagnostics; +#if !NETFRAMEWORK && !NETSTANDARD2_0 +using System.Diagnostics.CodeAnalysis; +#endif +using System.Globalization; +using Microsoft.Extensions.Configuration; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.DependencyInjection.Extensions; +using Microsoft.Extensions.Options; + +namespace OpenTelemetry.Internal; + +internal static class ConfigurationExtensions +{ + public static Action? LogInvalidEnvironmentVariable = null; + + public delegate bool TryParseFunc( + string value, +#if !NETFRAMEWORK && !NETSTANDARD2_0 + [NotNullWhen(true)] +#endif + out T? parsedValue); + + public static bool TryGetStringValue( + this IConfiguration configuration, + string key, +#if !NETFRAMEWORK && !NETSTANDARD2_0 + [NotNullWhen(true)] +#endif + out string? value) + { + value = configuration[key] is string configValue ? configValue : null; + + return !string.IsNullOrWhiteSpace(value); + } + + public static bool TryGetUriValue( + this IConfiguration configuration, + string key, +#if !NETFRAMEWORK && !NETSTANDARD2_0 + [NotNullWhen(true)] +#endif + out Uri? value) + { + if (!configuration.TryGetStringValue(key, out var stringValue)) + { + value = null; + return false; + } + + if (!Uri.TryCreate(stringValue, UriKind.Absolute, out value)) + { + LogInvalidEnvironmentVariable?.Invoke(key, stringValue!); + return false; + } + + return true; + } + + public static bool TryGetIntValue( + this IConfiguration configuration, + string key, + out int value) + { + if (!configuration.TryGetStringValue(key, out var stringValue)) + { + value = default; + return false; + } + + if (!int.TryParse(stringValue, NumberStyles.None, CultureInfo.InvariantCulture, out value)) + { + LogInvalidEnvironmentVariable?.Invoke(key, stringValue!); + return false; + } + + return true; + } + + public static bool TryGetValue( + this IConfiguration configuration, + string key, + TryParseFunc tryParseFunc, +#if !NETFRAMEWORK && !NETSTANDARD2_0 + [NotNullWhen(true)] +#endif + out T? value) + { + if (!configuration.TryGetStringValue(key, out var stringValue)) + { + value = default; + return false; + } + + if (!tryParseFunc(stringValue!, out value)) + { + LogInvalidEnvironmentVariable?.Invoke(key, stringValue!); + return false; + } + + return true; + } + + public static IServiceCollection RegisterOptionsFactory( + this IServiceCollection services, + Func optionsFactoryFunc) + where T : class, new() + { + Debug.Assert(services != null, "services was null"); + Debug.Assert(optionsFactoryFunc != null, "optionsFactoryFunc was null"); + + services.TryAddSingleton>(sp => + { + return new DelegatingOptionsFactory( + (c, n) => optionsFactoryFunc!(c), + sp.GetRequiredService(), + sp.GetServices>(), + sp.GetServices>(), + sp.GetServices>()); + }); + + return services!; + } + + public static IServiceCollection RegisterOptionsFactory( + this IServiceCollection services, + Func optionsFactoryFunc) + where T : class, new() + { + Debug.Assert(services != null, "services was null"); + Debug.Assert(optionsFactoryFunc != null, "optionsFactoryFunc was null"); + + services.TryAddSingleton>(sp => + { + return new DelegatingOptionsFactory( + (c, n) => optionsFactoryFunc!(sp, c, n), + sp.GetRequiredService(), + sp.GetServices>(), + sp.GetServices>(), + sp.GetServices>()); + }); + + return services!; + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/Options/DelegatingOptionsFactory.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/Options/DelegatingOptionsFactory.cs new file mode 100644 index 000000000000..01a93c8e866e --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/Options/DelegatingOptionsFactory.cs @@ -0,0 +1,116 @@ +// (Turns off StyleCop analysis in this file.) +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/* + Note: This class was copied from + https://github.com/dotnet/runtime/blob/e13e7388dedc6672381e61592c2e74385fe781a5/src/libraries/Microsoft.Extensions.Options/src/OptionsFactory.cs + and then modified to have delegate features needed by the SDK. In the future if + we take a dependency on Microsoft.Extensions.Options v5.0.0 (or greater), much + of this can be removed in favor of the "CreateInstance" API added in 5: + https://learn.microsoft.com/dotnet/api/microsoft.extensions.options.optionsfactory-1.createinstance?view=dotnet-plat-ext-5.0. + See https://github.com/open-telemetry/opentelemetry-dotnet/pull/4093 for an + example of how that works. +*/ + +#nullable enable + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using Microsoft.Extensions.Configuration; + +namespace Microsoft.Extensions.Options +{ + /// + /// Implementation of . + /// + /// The type of options being requested. + internal sealed class DelegatingOptionsFactory : + IOptionsFactory + where TOptions : class, new() + { + private readonly Func optionsFactoryFunc; + private readonly IConfiguration configuration; + private readonly IConfigureOptions[] _setups; + private readonly IPostConfigureOptions[] _postConfigures; + private readonly IValidateOptions[] _validations; + + /// + /// Initializes a new instance with the specified options configurations. + /// + /// + /// + /// The configuration actions to run. + /// The initialization actions to run. + /// The validations to run. + public DelegatingOptionsFactory( + Func optionsFactoryFunc, + IConfiguration configuration, + IEnumerable> setups, + IEnumerable> postConfigures, + IEnumerable> validations) + { + // The default DI container uses arrays under the covers. Take advantage of this knowledge + // by checking for an array and enumerate over that, so we don't need to allocate an enumerator. + // When it isn't already an array, convert it to one, but don't use System.Linq to avoid pulling Linq in to + // small trimmed applications. + + Debug.Assert(optionsFactoryFunc != null, "optionsFactoryFunc was null"); + Debug.Assert(configuration != null, "configuration was null"); + + this.optionsFactoryFunc = optionsFactoryFunc!; + this.configuration = configuration!; + _setups = setups as IConfigureOptions[] ?? new List>(setups).ToArray(); + _postConfigures = postConfigures as IPostConfigureOptions[] ?? new List>(postConfigures).ToArray(); + _validations = validations as IValidateOptions[] ?? new List>(validations).ToArray(); + } + + /// + /// Returns a configured instance with the given . + /// + /// The name of the instance to create. + /// The created instance with the given . + /// One or more return failed when validating the instance been created. + /// The does not have a public parameterless constructor or is . + public TOptions Create(string name) + { + TOptions options = this.optionsFactoryFunc(this.configuration, name); + foreach (IConfigureOptions setup in _setups) + { + if (setup is IConfigureNamedOptions namedSetup) + { + namedSetup.Configure(name, options); + } + else if (name == Options.DefaultName) + { + setup.Configure(options); + } + } + foreach (IPostConfigureOptions post in _postConfigures) + { + post.PostConfigure(name, options); + } + + if (_validations.Length > 0) + { + var failures = new List(); + foreach (IValidateOptions validate in _validations) + { + ValidateOptionsResult result = validate.Validate(name, options); + if (result is not null && result.Failed) + { + failures.AddRange(result.Failures); + } + } + if (failures.Count > 0) + { + throw new OptionsValidationException(name, typeof(TOptions), failures); + } + } + + return options; + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/PeerServiceResolver.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/PeerServiceResolver.cs new file mode 100644 index 000000000000..1a2bc37d0ae4 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/PeerServiceResolver.cs @@ -0,0 +1,111 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#nullable enable + +using System; +using System.Collections.Generic; +using System.Runtime.CompilerServices; +using OpenTelemetry.Trace; + +namespace OpenTelemetry.Exporter +{ + internal static class PeerServiceResolver + { + private static readonly Dictionary PeerServiceKeyResolutionDictionary = new(StringComparer.OrdinalIgnoreCase) + { + [SemanticConventions.AttributePeerService] = 0, // priority 0 (highest). + ["peer.hostname"] = 1, + ["peer.address"] = 1, + [SemanticConventions.AttributeHttpHost] = 2, // peer.service for Http. + [SemanticConventions.AttributeDbInstance] = 2, // peer.service for Redis. + }; + + public interface IPeerServiceState + { + string? PeerService { get; set; } + + int? PeerServicePriority { get; set; } + + string? HostName { get; set; } + + string? IpAddress { get; set; } + + long Port { get; set; } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void InspectTag(ref T state, string key, string? value) + where T : struct, IPeerServiceState + { + if (PeerServiceKeyResolutionDictionary.TryGetValue(key, out int priority) + && (state.PeerService == null || priority < state.PeerServicePriority)) + { + state.PeerService = value; + state.PeerServicePriority = priority; + } + else if (key == SemanticConventions.AttributeNetPeerName) + { + state.HostName = value; + } + else if (key == SemanticConventions.AttributeNetPeerIp) + { + state.IpAddress = value; + } + else if (key == SemanticConventions.AttributeNetPeerPort && long.TryParse(value, out var port)) + { + state.Port = port; + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void InspectTag(ref T state, string key, long value) + where T : struct, IPeerServiceState + { + if (key == SemanticConventions.AttributeNetPeerPort) + { + state.Port = value; + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static void Resolve(ref T state, out string? peerServiceName, out bool addAsTag) + where T : struct, IPeerServiceState + { + peerServiceName = state.PeerService; + + // If priority = 0 that means peer.service was included in tags + addAsTag = state.PeerServicePriority != 0; + + if (addAsTag) + { + var hostNameOrIpAddress = state.HostName ?? state.IpAddress; + + // peer.service has not already been included, but net.peer.name/ip and optionally net.peer.port are present + if (hostNameOrIpAddress != null) + { + peerServiceName = state.Port == default + ? hostNameOrIpAddress + : $"{hostNameOrIpAddress}:{state.Port}"; + } + else if (state.PeerService != null) + { + peerServiceName = state.PeerService; + } + } + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/PeriodicExportingMetricReaderHelper.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/PeriodicExportingMetricReaderHelper.cs new file mode 100644 index 000000000000..6fcc823c748a --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/PeriodicExportingMetricReaderHelper.cs @@ -0,0 +1,45 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#nullable enable + +namespace OpenTelemetry.Metrics; + +internal static class PeriodicExportingMetricReaderHelper +{ + internal const int DefaultExportIntervalMilliseconds = 60000; + internal const int DefaultExportTimeoutMilliseconds = 30000; + + internal static PeriodicExportingMetricReader CreatePeriodicExportingMetricReader( + BaseExporter exporter, + MetricReaderOptions options, + int defaultExportIntervalMilliseconds = DefaultExportIntervalMilliseconds, + int defaultExportTimeoutMilliseconds = DefaultExportTimeoutMilliseconds) + { + var exportInterval = + options.PeriodicExportingMetricReaderOptions.ExportIntervalMilliseconds ?? defaultExportIntervalMilliseconds; + + var exportTimeout = + options.PeriodicExportingMetricReaderOptions.ExportTimeoutMilliseconds ?? defaultExportTimeoutMilliseconds; + + var metricReader = new PeriodicExportingMetricReader(exporter, exportInterval, exportTimeout) + { + TemporalityPreference = options.TemporalityPreference, + }; + + return metricReader; + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/PooledList.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/PooledList.cs new file mode 100644 index 000000000000..f76844d7b1e3 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/PooledList.cs @@ -0,0 +1,152 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System; +using System.Buffers; +using System.Collections; +using System.Collections.Generic; + +namespace OpenTelemetry.Internal; + +internal readonly struct PooledList : IEnumerable, ICollection +{ + private static int lastAllocatedSize = 64; + + private readonly T[] buffer; + + private PooledList(T[] buffer, int count) + { + this.buffer = buffer; + this.Count = count; + } + + public int Count { get; } + + public bool IsEmpty => this.Count == 0; + + bool ICollection.IsSynchronized => false; + + object ICollection.SyncRoot => this; + + public ref T this[int index] + { + get => ref this.buffer[index]; + } + + public static PooledList Create() + { + return new PooledList(ArrayPool.Shared.Rent(lastAllocatedSize), 0); + } + + public static void Add(ref PooledList list, T item) + { + Guard.ThrowIfNull(list.buffer); + + var buffer = list.buffer; + + if (list.Count >= buffer.Length) + { + lastAllocatedSize = buffer.Length * 2; + var previousBuffer = buffer; + + buffer = ArrayPool.Shared.Rent(lastAllocatedSize); + + var span = previousBuffer.AsSpan(); + span.CopyTo(buffer); + ArrayPool.Shared.Return(previousBuffer); + } + + buffer[list.Count] = item; + list = new PooledList(buffer, list.Count + 1); + } + + public static void Clear(ref PooledList list) + { + list = new PooledList(list.buffer, 0); + } + + public void Return() + { + var buffer = this.buffer; + if (buffer != null) + { + ArrayPool.Shared.Return(buffer); + } + } + + void ICollection.CopyTo(Array array, int index) + { + Array.Copy(this.buffer, 0, array, index, this.Count); + } + + public Enumerator GetEnumerator() + { + return new Enumerator(in this); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return new Enumerator(in this); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return new Enumerator(in this); + } + + public struct Enumerator : IEnumerator, IEnumerator + { + private readonly T[] buffer; + private readonly int count; + private int index; + private T current; + + public Enumerator(in PooledList list) + { + this.buffer = list.buffer; + this.count = list.Count; + this.index = 0; + this.current = default; + } + + public T Current { get => this.current; } + + object IEnumerator.Current { get => this.Current; } + + public void Dispose() + { + } + + public bool MoveNext() + { + if (this.index < this.count) + { + this.current = this.buffer[this.index++]; + return true; + } + + this.index = this.count + 1; + this.current = default; + return false; + } + + void IEnumerator.Reset() + { + this.index = 0; + this.current = default; + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/ResourceSemanticConventions.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/ResourceSemanticConventions.cs new file mode 100644 index 000000000000..ca70e67aaf63 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/ResourceSemanticConventions.cs @@ -0,0 +1,66 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#nullable enable + +namespace OpenTelemetry.Resources; + +internal static class ResourceSemanticConventions +{ + public const string AttributeServiceName = "service.name"; + public const string AttributeServiceNamespace = "service.namespace"; + public const string AttributeServiceInstance = "service.instance.id"; + public const string AttributeServiceVersion = "service.version"; + + public const string AttributeTelemetrySdkName = "telemetry.sdk.name"; + public const string AttributeTelemetrySdkLanguage = "telemetry.sdk.language"; + public const string AttributeTelemetrySdkVersion = "telemetry.sdk.version"; + + public const string AttributeContainerName = "container.name"; + public const string AttributeContainerImage = "container.image.name"; + public const string AttributeContainerTag = "container.image.tag"; + + public const string AttributeFaasName = "faas.name"; + public const string AttributeFaasId = "faas.id"; + public const string AttributeFaasVersion = "faas.version"; + public const string AttributeFaasInstance = "faas.instance"; + + public const string AttributeK8sCluster = "k8s.cluster.name"; + public const string AttributeK8sNamespace = "k8s.namespace.name"; + public const string AttributeK8sPod = "k8s.pod.name"; + public const string AttributeK8sDeployment = "k8s.deployment.name"; + + public const string AttributeHostHostname = "host.hostname"; + public const string AttributeHostId = "host.id"; + public const string AttributeHostName = "host.name"; + public const string AttributeHostType = "host.type"; + public const string AttributeHostImageName = "host.image.name"; + public const string AttributeHostImageId = "host.image.id"; + public const string AttributeHostImageVersion = "host.image.version"; + + public const string AttributeProcessId = "process.id"; + public const string AttributeProcessExecutableName = "process.executable.name"; + public const string AttributeProcessExecutablePath = "process.executable.path"; + public const string AttributeProcessCommand = "process.command"; + public const string AttributeProcessCommandLine = "process.command_line"; + public const string AttributeProcessUsername = "process.username"; + + public const string AttributeCloudProvider = "cloud.provider"; + public const string AttributeCloudAccount = "cloud.account.id"; + public const string AttributeCloudRegion = "cloud.region"; + public const string AttributeCloudZone = "cloud.zone"; + public const string AttributeComponent = "component"; +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/SemanticConventions.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/SemanticConventions.cs new file mode 100644 index 000000000000..3f0ce13a20b4 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/SemanticConventions.cs @@ -0,0 +1,131 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#nullable enable + +namespace OpenTelemetry.Trace; + +/// +/// Constants for semantic attribute names outlined by the OpenTelemetry specifications. +/// and +/// . +/// +internal static class SemanticConventions +{ + // The set of constants matches the specification as of this commit. + // https://github.com/open-telemetry/opentelemetry-specification/tree/main/specification/trace/semantic_conventions + // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/semantic_conventions/exceptions.md + public const string AttributeNetTransport = "net.transport"; + public const string AttributeNetPeerIp = "net.peer.ip"; + public const string AttributeNetPeerPort = "net.peer.port"; + public const string AttributeNetPeerName = "net.peer.name"; + public const string AttributeNetHostIp = "net.host.ip"; + public const string AttributeNetHostPort = "net.host.port"; + public const string AttributeNetHostName = "net.host.name"; + + public const string AttributeEnduserId = "enduser.id"; + public const string AttributeEnduserRole = "enduser.role"; + public const string AttributeEnduserScope = "enduser.scope"; + + public const string AttributePeerService = "peer.service"; + + public const string AttributeHttpMethod = "http.method"; + public const string AttributeHttpUrl = "http.url"; + public const string AttributeHttpTarget = "http.target"; + public const string AttributeHttpHost = "http.host"; + public const string AttributeHttpScheme = "http.scheme"; + public const string AttributeHttpStatusCode = "http.status_code"; + public const string AttributeHttpStatusText = "http.status_text"; + public const string AttributeHttpFlavor = "http.flavor"; + public const string AttributeHttpServerName = "http.server_name"; + public const string AttributeHttpRoute = "http.route"; + public const string AttributeHttpClientIP = "http.client_ip"; + public const string AttributeHttpUserAgent = "http.user_agent"; + public const string AttributeHttpRequestContentLength = "http.request_content_length"; + public const string AttributeHttpRequestContentLengthUncompressed = "http.request_content_length_uncompressed"; + public const string AttributeHttpResponseContentLength = "http.response_content_length"; + public const string AttributeHttpResponseContentLengthUncompressed = "http.response_content_length_uncompressed"; + + public const string AttributeDbSystem = "db.system"; + public const string AttributeDbConnectionString = "db.connection_string"; + public const string AttributeDbUser = "db.user"; + public const string AttributeDbMsSqlInstanceName = "db.mssql.instance_name"; + public const string AttributeDbJdbcDriverClassName = "db.jdbc.driver_classname"; + public const string AttributeDbName = "db.name"; + public const string AttributeDbStatement = "db.statement"; + public const string AttributeDbOperation = "db.operation"; + public const string AttributeDbInstance = "db.instance"; + public const string AttributeDbUrl = "db.url"; + public const string AttributeDbCassandraKeyspace = "db.cassandra.keyspace"; + public const string AttributeDbHBaseNamespace = "db.hbase.namespace"; + public const string AttributeDbRedisDatabaseIndex = "db.redis.database_index"; + public const string AttributeDbMongoDbCollection = "db.mongodb.collection"; + + public const string AttributeRpcSystem = "rpc.system"; + public const string AttributeRpcService = "rpc.service"; + public const string AttributeRpcMethod = "rpc.method"; + public const string AttributeRpcGrpcStatusCode = "rpc.grpc.status_code"; + + public const string AttributeMessageType = "message.type"; + public const string AttributeMessageId = "message.id"; + public const string AttributeMessageCompressedSize = "message.compressed_size"; + public const string AttributeMessageUncompressedSize = "message.uncompressed_size"; + + public const string AttributeFaasTrigger = "faas.trigger"; + public const string AttributeFaasExecution = "faas.execution"; + public const string AttributeFaasDocumentCollection = "faas.document.collection"; + public const string AttributeFaasDocumentOperation = "faas.document.operation"; + public const string AttributeFaasDocumentTime = "faas.document.time"; + public const string AttributeFaasDocumentName = "faas.document.name"; + public const string AttributeFaasTime = "faas.time"; + public const string AttributeFaasCron = "faas.cron"; + + public const string AttributeMessagingSystem = "messaging.system"; + public const string AttributeMessagingDestination = "messaging.destination"; + public const string AttributeMessagingDestinationKind = "messaging.destination_kind"; + public const string AttributeMessagingTempDestination = "messaging.temp_destination"; + public const string AttributeMessagingProtocol = "messaging.protocol"; + public const string AttributeMessagingProtocolVersion = "messaging.protocol_version"; + public const string AttributeMessagingUrl = "messaging.url"; + public const string AttributeMessagingMessageId = "messaging.message_id"; + public const string AttributeMessagingConversationId = "messaging.conversation_id"; + public const string AttributeMessagingPayloadSize = "messaging.message_payload_size_bytes"; + public const string AttributeMessagingPayloadCompressedSize = "messaging.message_payload_compressed_size_bytes"; + public const string AttributeMessagingOperation = "messaging.operation"; + + public const string AttributeExceptionEventName = "exception"; + public const string AttributeExceptionType = "exception.type"; + public const string AttributeExceptionMessage = "exception.message"; + public const string AttributeExceptionStacktrace = "exception.stacktrace"; + + // v1.21.0 + // https://github.com/open-telemetry/semantic-conventions/blob/v1.21.0/docs/http/http-spans.md + // https://github.com/open-telemetry/semantic-conventions/blob/v1.21.0/docs/database/database-spans.md + // https://github.com/open-telemetry/semantic-conventions/blob/v1.21.0/docs/rpc/rpc-spans.md + public const string AttributeClientAddress = "client.address"; + public const string AttributeClientPort = "client.port"; + public const string AttributeHttpRequestMethod = "http.request.method"; // replaces: "http.method" (AttributeHttpMethod) + public const string AttributeHttpResponseStatusCode = "http.response.status_code"; // replaces: "http.status_code" (AttributeHttpStatusCode) + public const string AttributeNetworkProtocolVersion = "network.protocol.version"; // replaces: "http.flavor" (AttributeHttpFlavor) + public const string AttributeServerAddress = "server.address"; // replaces: "net.host.name" (AttributeNetHostName) and "net.peer.name" (AttributeNetPeerName) + public const string AttributeServerPort = "server.port"; // replaces: "net.host.port" (AttributeNetHostPort) and "net.peer.port" (AttributeNetPeerPort) + public const string AttributeServerSocketAddress = "server.socket.address"; // replaces: "net.peer.ip" (AttributeNetPeerIp) + public const string AttributeUrlFull = "url.full"; // replaces: "http.url" (AttributeHttpUrl) + public const string AttributeUrlPath = "url.path"; // replaces: "http.target" (AttributeHttpTarget) + public const string AttributeUrlScheme = "url.scheme"; // replaces: "http.scheme" (AttributeHttpScheme) + public const string AttributeUrlQuery = "url.query"; + public const string AttributeUserAgentOriginal = "user_agent.original"; // replaces: "http.user_agent" (AttributeHttpUserAgent) +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/Shims/IsExternalInit.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/Shims/IsExternalInit.cs new file mode 100644 index 000000000000..85984f44e07a --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/Shims/IsExternalInit.cs @@ -0,0 +1,24 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#if NETFRAMEWORK || NETSTANDARD2_0_OR_GREATER +namespace System.Runtime.CompilerServices; + +// This enabled "init" keyword in net462 + netstandard2.0 targets. +internal sealed class IsExternalInit +{ +} +#endif diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/Shims/NullableAttributes.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/Shims/NullableAttributes.cs new file mode 100644 index 000000000000..78bcfeab9ae4 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/Shims/NullableAttributes.cs @@ -0,0 +1,51 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +// Source: https://github.com/dotnet/runtime/blob/main/src/libraries/System.Private.CoreLib/src/System/Diagnostics/CodeAnalysis/NullableAttributes.cs + +#pragma warning disable SA1649 // File name should match first type name +#pragma warning disable SA1402 // File may only contain a single type + +#if NETFRAMEWORK || NETSTANDARD2_0 +namespace System.Diagnostics.CodeAnalysis +{ + /// Specifies that null is allowed as an input even if the corresponding type disallows it. + [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property, Inherited = false)] + internal sealed class AllowNullAttribute : Attribute + { + } + + /// Specifies that an output may be null even if the corresponding type disallows it. + [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, Inherited = false)] + internal sealed class MaybeNullAttribute : Attribute + { + } + + /// Specifies that when a method returns , the parameter will not be null even if the corresponding type allows it. + [AttributeUsage(AttributeTargets.Parameter, Inherited = false)] + internal sealed class NotNullWhenAttribute : Attribute + { + /// Initializes the attribute with the specified return value condition. + /// + /// The return value condition. If the method returns this value, the associated parameter will not be null. + /// + public NotNullWhenAttribute(bool returnValue) => ReturnValue = returnValue; + + /// Gets the return value condition. + public bool ReturnValue { get; } + } +} +#endif diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/Shims/UnconditionalSuppressMessageAttribute.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/Shims/UnconditionalSuppressMessageAttribute.cs new file mode 100644 index 000000000000..0d2c776278d4 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/Shims/UnconditionalSuppressMessageAttribute.cs @@ -0,0 +1,98 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#nullable enable + +namespace System.Diagnostics.CodeAnalysis; + +/// +/// Suppresses reporting of a specific rule violation, allowing multiple suppressions on a +/// single code artifact. +/// +/// +/// is different than +/// in that it doesn't have a +/// . So it is always preserved in the compiled assembly. +/// +[AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)] +internal sealed class UnconditionalSuppressMessageAttribute : Attribute +{ + /// + /// Initializes a new instance of the + /// class, specifying the category of the tool and the identifier for an analysis rule. + /// + /// The category for the attribute. + /// The identifier of the analysis rule the attribute applies to. + public UnconditionalSuppressMessageAttribute(string category, string checkId) + { + this.Category = category; + this.CheckId = checkId; + } + + /// + /// Gets the category identifying the classification of the attribute. + /// + /// + /// The property describes the tool or tool analysis category + /// for which a message suppression attribute applies. + /// + public string Category { get; } + + /// + /// Gets the identifier of the analysis tool rule to be suppressed. + /// + /// + /// Concatenated together, the and + /// properties form a unique check identifier. + /// + public string CheckId { get; } + + /// + /// Gets or sets the scope of the code that is relevant for the attribute. + /// + /// + /// The Scope property is an optional argument that specifies the metadata scope for which + /// the attribute is relevant. + /// + public string? Scope { get; set; } + + /// + /// Gets or sets a fully qualified path that represents the target of the attribute. + /// + /// + /// The property is an optional argument identifying the analysis target + /// of the attribute. An example value is "System.IO.Stream.ctor():System.Void". + /// Because it is fully qualified, it can be long, particularly for targets such as parameters. + /// The analysis tool user interface should be capable of automatically formatting the parameter. + /// + public string? Target { get; set; } + + /// + /// Gets or sets an optional argument expanding on exclusion criteria. + /// + /// + /// The property is an optional argument that specifies additional + /// exclusion where the literal metadata target is not sufficiently precise. For example, + /// the cannot be applied within a method, + /// and it may be desirable to suppress a violation against a statement in the method that will + /// give a rule violation, but not against all statements in the method. + /// + public string? MessageId { get; set; } + + /// + /// Gets or sets the justification for suppressing the code analysis message. + /// + public string? Justification { get; set; } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/SpanAttributeConstants.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/SpanAttributeConstants.cs new file mode 100644 index 000000000000..735a8ea011dc --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/SpanAttributeConstants.cs @@ -0,0 +1,29 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#nullable enable + +namespace OpenTelemetry.Trace; + +/// +/// Defines well-known span attribute keys. +/// +internal static class SpanAttributeConstants +{ + public const string StatusCodeKey = "otel.status_code"; + public const string StatusDescriptionKey = "otel.status_description"; + public const string DatabaseStatementTypeKey = "db.statement_type"; +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/SpanHelper.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/SpanHelper.cs new file mode 100644 index 000000000000..6f909db58c02 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/SpanHelper.cs @@ -0,0 +1,44 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +using System.Diagnostics; + +namespace OpenTelemetry.Trace +{ + /// + /// A collection of helper methods to be used when building spans. + /// + internal static class SpanHelper + { + /// + /// Helper method that populates span properties from http status code according + /// to https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/semantic_conventions/http.md#status. + /// + /// The span kind. + /// Http status code. + /// Resolved span for the Http status code. + public static ActivityStatusCode ResolveSpanStatusForHttpStatusCode(ActivityKind kind, int httpStatusCode) + { + var upperBound = kind == ActivityKind.Client ? 399 : 499; + if (httpStatusCode >= 100 && httpStatusCode <= upperBound) + { + return ActivityStatusCode.Unset; + } + + return ActivityStatusCode.Error; + } + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/StatusHelper.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/StatusHelper.cs new file mode 100644 index 000000000000..57c2dd060183 --- /dev/null +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/src/Vendoring/Shared/StatusHelper.cs @@ -0,0 +1,74 @@ +// +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#nullable enable + +using System; +using System.Runtime.CompilerServices; +using OpenTelemetry.Trace; + +namespace OpenTelemetry.Internal; + +internal static class StatusHelper +{ + public const string UnsetStatusCodeTagValue = "UNSET"; + public const string OkStatusCodeTagValue = "OK"; + public const string ErrorStatusCodeTagValue = "ERROR"; + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static string? GetTagValueForStatusCode(StatusCode statusCode) + { + return statusCode switch + { + /* + * Note: Order here does matter for perf. Unset is + * first because assumption is most spans will be + * Unset, then Error. Ok is not set by the SDK. + */ + StatusCode.Unset => UnsetStatusCodeTagValue, + StatusCode.Error => ErrorStatusCodeTagValue, + StatusCode.Ok => OkStatusCodeTagValue, + _ => null, + }; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static StatusCode? GetStatusCodeForTagValue(string? statusCodeTagValue) + { + return statusCodeTagValue switch + { + /* + * Note: Order here does matter for perf. Unset is + * first because assumption is most spans will be + * Unset, then Error. Ok is not set by the SDK. + */ + not null when UnsetStatusCodeTagValue.Equals(statusCodeTagValue, StringComparison.OrdinalIgnoreCase) => StatusCode.Unset, + not null when ErrorStatusCodeTagValue.Equals(statusCodeTagValue, StringComparison.OrdinalIgnoreCase) => StatusCode.Error, + not null when OkStatusCodeTagValue.Equals(statusCodeTagValue, StringComparison.OrdinalIgnoreCase) => StatusCode.Ok, + _ => null, + }; + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool TryGetStatusCodeForTagValue(string? statusCodeTagValue, out StatusCode statusCode) + { + StatusCode? tempStatusCode = GetStatusCodeForTagValue(statusCodeTagValue); + + statusCode = tempStatusCode ?? default; + + return tempStatusCode.HasValue; + } +} diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/tests/Azure.Monitor.OpenTelemetry.AspNetCore.Integration.Tests/Azure.Monitor.OpenTelemetry.AspNetCore.Integration.Tests.csproj b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/tests/Azure.Monitor.OpenTelemetry.AspNetCore.Integration.Tests/Azure.Monitor.OpenTelemetry.AspNetCore.Integration.Tests.csproj index 2476851867bf..61eef0256dff 100644 --- a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/tests/Azure.Monitor.OpenTelemetry.AspNetCore.Integration.Tests/Azure.Monitor.OpenTelemetry.AspNetCore.Integration.Tests.csproj +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/tests/Azure.Monitor.OpenTelemetry.AspNetCore.Integration.Tests/Azure.Monitor.OpenTelemetry.AspNetCore.Integration.Tests.csproj @@ -18,6 +18,14 @@ + + + + + + + + diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/tests/Azure.Monitor.OpenTelemetry.AspNetCore.Tests/Azure.Monitor.OpenTelemetry.AspNetCore.Tests.csproj b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/tests/Azure.Monitor.OpenTelemetry.AspNetCore.Tests/Azure.Monitor.OpenTelemetry.AspNetCore.Tests.csproj index 816cc45d6f43..a67c53f37948 100644 --- a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/tests/Azure.Monitor.OpenTelemetry.AspNetCore.Tests/Azure.Monitor.OpenTelemetry.AspNetCore.Tests.csproj +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/tests/Azure.Monitor.OpenTelemetry.AspNetCore.Tests/Azure.Monitor.OpenTelemetry.AspNetCore.Tests.csproj @@ -26,4 +26,12 @@ + + + + + + + + diff --git a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/tests/Azure.Monitor.OpenTelemetry.AspNetCore.Tests/DefaultAzureMonitorOptionsTests.cs b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/tests/Azure.Monitor.OpenTelemetry.AspNetCore.Tests/DefaultAzureMonitorOptionsTests.cs index 888ac06f2349..0fd36d8e4dc2 100644 --- a/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/tests/Azure.Monitor.OpenTelemetry.AspNetCore.Tests/DefaultAzureMonitorOptionsTests.cs +++ b/sdk/monitor/Azure.Monitor.OpenTelemetry.AspNetCore/tests/Azure.Monitor.OpenTelemetry.AspNetCore.Tests/DefaultAzureMonitorOptionsTests.cs @@ -109,7 +109,8 @@ public void VerifyConfigure_SetsConnectionString(bool jsonAzureMonitor, bool jso if (iconfigEnvVar) { - configBulider.AddEnvironmentVariables(); + // TODO: This test case requires a fix, even after commenting this section test passes. + // configBulider.AddEnvironmentVariables(); } var configuration = configBulider.Build();