[AWS] Use factories

- Use `ActivitySourceFactory` and `MeterFactory`.
- Add support for tags to `MeterFactory`.
- Fix `MeterFactory` namespace.

Author: martincostello

src/OpenTelemetry.Instrumentation.AWS/Implementation/Metrics/AWSMeterProvider.cs

@@ -5,50 +5,30 @@
 using Amazon.Runtime.Telemetry;
 using Amazon.Runtime.Telemetry.Metrics;
 using OpenTelemetry.AWS;
-using OpenTelemetry.Internal;
 
 namespace OpenTelemetry.Instrumentation.AWS.Implementation.Metrics;
 
 internal sealed class AWSMeterProvider(SemanticConventionVersion version) : MeterProvider
 {
-    private static readonly string MeterVersion = GetMeterVersion();
-
     private readonly ConcurrentDictionary<string, AWSMeter> meters = new();
-    private readonly string telemetrySchemaUrl = AWSSemanticConventions.GetTelemetrySchemaUrl(version);
+    private readonly Version semanticConventionVersion = AWSSemanticConventions.GetVersion(version);
 
     public override Meter GetMeter(string scope, Attributes? attributes = null)
     {
         if (!this.meters.TryGetValue(scope, out var meter))
         {
 #if NET
-            meter = this.meters.GetOrAdd(scope, static (name, state) => CreateMeter(name, state), (this.telemetrySchemaUrl, attributes?.AllAttributes));
+            meter = this.meters.GetOrAdd(scope, static (name, state) => CreateMeter(name, state), (this.semanticConventionVersion, attributes?.AllAttributes));
 #else
-            meter = this.meters.GetOrAdd(scope, (name) => CreateMeter(name, (this.telemetrySchemaUrl, attributes?.AllAttributes)));
+            meter = this.meters.GetOrAdd(scope, (name) => CreateMeter(name, (this.semanticConventionVersion, attributes?.AllAttributes)));
 #endif
         }
 
         return meter;
 
-        static AWSMeter CreateMeter(string name, (string SchemaUrl, IEnumerable<KeyValuePair<string, object?>>? Attributes) state)
+        static AWSMeter CreateMeter(string name, (Version Version, IEnumerable<KeyValuePair<string, object?>>? Attributes) state)
         {
-            var options = new System.Diagnostics.Metrics.MeterOptions(name)
-            {
-                TelemetrySchemaUrl = state.SchemaUrl,
-                Version = MeterVersion,
-            };
-
-            if (state.Attributes is { } attributes)
-            {
-                options.Tags = attributes;
-            }
-
-            return new AWSMeter(new System.Diagnostics.Metrics.Meter(options));
+            return new AWSMeter(OpenTelemetry.Metrics.MeterFactory.Create<AWSMeterProvider>(state.Version, state.Attributes));
         }
     }
-
-    private static string GetMeterVersion()
-    {
-        var assembly = typeof(AWSMeterProvider).Assembly;
-        return assembly.GetPackageVersion();
-    }
 }

src/OpenTelemetry.Instrumentation.AWS/Implementation/Tracing/AWSTracerProvider.cs

@@ -2,48 +2,32 @@
 // SPDX-License-Identifier: Apache-2.0
 
 using System.Collections.Concurrent;
-using System.Diagnostics;
 using Amazon.Runtime.Telemetry.Tracing;
 using OpenTelemetry.AWS;
-using OpenTelemetry.Internal;
 
 namespace OpenTelemetry.Instrumentation.AWS.Implementation.Tracing;
 
 internal sealed class AWSTracerProvider(SemanticConventionVersion version) : TracerProvider
 {
-    private static readonly string ActivitySourceVersion = GetActivitySourceVersion();
-
     private readonly ConcurrentDictionary<string, AWSTracer> tracers = new();
-    private readonly string telemetrySchemaUrl = AWSSemanticConventions.GetTelemetrySchemaUrl(version);
+    private readonly Version semanticConventionVersion = AWSSemanticConventions.GetVersion(version);
 
     public override Tracer GetTracer(string scope)
     {
         if (!this.tracers.TryGetValue(scope, out var awsTracer))
         {
 #if NET
-            awsTracer = this.tracers.GetOrAdd(scope, static (name, schemaUrl) => CreateTracer(name, schemaUrl), this.telemetrySchemaUrl);
+            awsTracer = this.tracers.GetOrAdd(scope, static (name, version) => CreateTracer(name, version), this.semanticConventionVersion);
 #else
-            awsTracer = this.tracers.GetOrAdd(scope, (name) => CreateTracer(name, this.telemetrySchemaUrl));
+            awsTracer = this.tracers.GetOrAdd(scope, (name) => CreateTracer(name, this.semanticConventionVersion));
 #endif
         }
 
         return awsTracer;
 
-        static AWSTracer CreateTracer(string name, string telemetrySchemaUrl)
+        static AWSTracer CreateTracer(string name, Version version)
         {
-            var options = new ActivitySourceOptions(name)
-            {
-                TelemetrySchemaUrl = telemetrySchemaUrl,
-                Version = ActivitySourceVersion,
-            };
-
-            return new AWSTracer(new ActivitySource(options));
+            return new AWSTracer(Trace.ActivitySourceFactory.Create<AWSTracerProvider>(version));
         }
     }
-
-    private static string GetActivitySourceVersion()
-    {
-        var assembly = typeof(AWSTracerProvider).Assembly;
-        return assembly.GetPackageVersion();
-    }
 }

src/OpenTelemetry.Instrumentation.AWS/OpenTelemetry.Instrumentation.AWS.csproj

@@ -32,9 +32,11 @@
   </ItemGroup>
 
   <ItemGroup>
-    <Compile Include="$(RepoRoot)\src\Shared\AWS\*.cs" Link="Includes\AWS\%(Filename).cs" />
+    <Compile Include="$(RepoRoot)\src\Shared\ActivitySourceFactory.cs" Link="Includes\ActivitySourceFactory.cs" />
     <Compile Include="$(RepoRoot)\src\Shared\AssemblyVersionExtensions.cs" Link="Includes\AssemblyVersionExtensions.cs" />
+    <Compile Include="$(RepoRoot)\src\Shared\AWS\*.cs" Link="Includes\AWS\%(Filename).cs" />
     <Compile Include="$(RepoRoot)\src\Shared\Guard.cs" Link="Includes\Guard.cs" />
+    <Compile Include="$(RepoRoot)\src\Shared\MeterFactory.cs" Link="Includes\MeterFactory.cs" />
   </ItemGroup>
 
 </Project>

src/OpenTelemetry.Instrumentation.AWSLambda/AWSLambdaWrapper.cs

@@ -256,17 +256,6 @@ private static async Task<TResult> TraceInternalAsync<TInput, TResult>(
         }
     }
 
-    private static ActivitySource CreateActivitySource()
-    {
-        var assembly = typeof(AWSLambdaWrapper).Assembly;
-        var version = assembly.GetPackageVersion();
-
-        var activitySourceOptions = new ActivitySourceOptions(ActivitySourceName)
-        {
-            TelemetrySchemaUrl = AWSSemanticConventions.SchemaUrl,
-            Version = version,
-        };
-
-        return new(activitySourceOptions);
-    }
+    private static ActivitySource CreateActivitySource() =>
+        ActivitySourceFactory.Create(typeof(AWSLambdaWrapper), AWSSemanticConventions.Version);
 }

src/OpenTelemetry.Instrumentation.AWSLambda/OpenTelemetry.Instrumentation.AWSLambda.csproj

@@ -34,8 +34,9 @@
   </ItemGroup>
 
   <ItemGroup>
-    <Compile Include="$(RepoRoot)\src\Shared\AWS\*.cs" Link="Includes\AWS\%(Filename).cs" />
+    <Compile Include="$(RepoRoot)\src\Shared\ActivitySourceFactory.cs" Link="Includes\ActivitySourceFactory.cs" />
     <Compile Include="$(RepoRoot)\src\Shared\AssemblyVersionExtensions.cs" Link="Includes\AssemblyVersionExtensions.cs" />
+    <Compile Include="$(RepoRoot)\src\Shared\AWS\*.cs" Link="Includes\AWS\%(Filename).cs" />
     <Compile Include="$(RepoRoot)\src\Shared\Guard.cs" Link="Includes\Guard.cs" />
   </ItemGroup>
 

src/OpenTelemetry.Instrumentation.AspNet/AspNetInstrumentation.cs

@@ -17,7 +17,7 @@ internal sealed class AspNetInstrumentation : IDisposable
 
     public static readonly Version SemanticConventionsVersion = new(1, 36, 0);
     public static readonly ActivitySource ActivitySource = ActivitySourceFactory.Create<AspNetInstrumentation>(SemanticConventionsVersion);
-    public static readonly Meter Meter = MeterFactory.Create<AspNetInstrumentation>(SemanticConventionsVersion);
+    public static readonly Meter Meter = Metrics.MeterFactory.Create<AspNetInstrumentation>(SemanticConventionsVersion);
 
     public static readonly Histogram<double> HttpServerDuration = Meter.CreateHistogram(
         "http.server.request.duration",

src/OpenTelemetry.Instrumentation.SqlClient/Implementation/SqlTelemetryHelper.cs

@@ -3,6 +3,7 @@
 
 using System.Diagnostics;
 using System.Diagnostics.Metrics;
+using OpenTelemetry.Metrics;
 using OpenTelemetry.Trace;
 
 namespace OpenTelemetry.Instrumentation.SqlClient.Implementation;

src/Shared/AWS/AWSSemanticConventions.cs

@@ -79,7 +79,7 @@ internal partial class AWSSemanticConventions
     /// <inheritdoc cref="TagBuilderImpl"/>
     public TagBuilderImpl TagBuilder { get; }
 
-    public string SchemaUrl { get; }
+    public Version Version { get; }
 
     /// <summary>
     /// Returns attribute names whose values must be reported as a <c>string[]</c>
@@ -100,7 +100,7 @@ public AWSSemanticConventions(SemanticConventionVersion semanticConventionVersio
         this.AttributeBuilder = new(this);
         this.ParameterMappingBuilder = new(this);
         this.TagBuilder = new(this);
-        this.SchemaUrl = GetTelemetrySchemaUrl(this.semanticConventionVersion);
+        this.Version = GetVersion(this.semanticConventionVersion);
     }
 
     /// <summary>
@@ -454,17 +454,12 @@ public TagBuilderImpl(AWSSemanticConventions semanticConventions)
         #endregion
     }
 
-    internal static string GetTelemetrySchemaUrl(SemanticConventionVersion semanticConventionVersion)
+    internal static Version GetVersion(SemanticConventionVersion semanticConventionVersion) => semanticConventionVersion switch
     {
-        var versionString = semanticConventionVersion switch
-        {
-            SemanticConventionVersion.Latest or SemanticConventionVersion.V1_29_0 => "1.29.0",
-            SemanticConventionVersion.V1_28_0 => "1.28.0",
-            _ => throw new InvalidEnumArgumentException(nameof(semanticConventionVersion), (int)semanticConventionVersion, typeof(SemanticConventionVersion)),
-        };
-
-        return $"https://opentelemetry.io/schemas/{versionString}";
-    }
+        SemanticConventionVersion.Latest or SemanticConventionVersion.V1_29_0 => new(1, 29, 0),
+        SemanticConventionVersion.V1_28_0 => new(1, 28, 0),
+        _ => throw new InvalidEnumArgumentException(nameof(semanticConventionVersion), (int)semanticConventionVersion, typeof(SemanticConventionVersion)),
+    };
 
     private AttributeBuilderImpl Add(AttributeBuilderImpl attributes, Func<AWSSemanticConventionsBase, string> attributeNameFunc, Func<AWSSemanticConventionsBase, string> valueFunc) =>
         this.Add(attributes, attributeNameFunc, valueFunc(this.GetSemanticConventionVersion()));

src/Shared/MeterFactory.cs

@@ -4,7 +4,7 @@
 using System.Diagnostics.Metrics;
 using OpenTelemetry.Internal;
 
-namespace OpenTelemetry.Trace;
+namespace OpenTelemetry.Metrics;
 
 internal static class MeterFactory
 {
@@ -14,18 +14,20 @@ internal static class MeterFactory
     /// </summary>
     /// <typeparam name="T">The type for which the <see cref="Meter"/> is created for its assembly.</typeparam>
     /// <param name="semanticConventionsVersion">The version of the semantic conventions.</param>
+    /// <param name="tags">The optional tags to associate with the created <see cref="Meter"/>.</param>
     /// <returns>A new <see cref="Meter"/> instance.</returns>
-    public static Meter Create<T>(Version semanticConventionsVersion)
-        => Create(typeof(T), semanticConventionsVersion);
+    public static Meter Create<T>(Version semanticConventionsVersion, IEnumerable<KeyValuePair<string, object?>>? tags = null)
+        => Create(typeof(T), semanticConventionsVersion, tags);
 
     /// <summary>
     /// Creates a new <see cref="Meter"/> for the assembly associated
     /// with the specified type and semantic conventions version.
     /// </summary>
     /// <param name="type">The type for which the <see cref="Meter"/> is created for its assembly.</param>
     /// <param name="semanticConventionsVersion">The version of the semantic conventions.</param>
+    /// <param name="tags">The optional tags to associate with the created <see cref="Meter"/>.</param>
     /// <returns>A new <see cref="Meter"/> instance.</returns>
-    public static Meter Create(Type type, Version semanticConventionsVersion)
+    public static Meter Create(Type type, Version semanticConventionsVersion, IEnumerable<KeyValuePair<string, object?>>? tags = null)
     {
         Guard.ThrowIfNull(type);
         Guard.ThrowIfNull(semanticConventionsVersion);
@@ -45,6 +47,11 @@ public static Meter Create(Type type, Version semanticConventionsVersion)
             Version = version,
         };
 
+        if (tags is not null)
+        {
+            options.Tags = tags;
+        }
+
         return new(options);
     }
 }

test/OpenTelemetry.Contrib.Shared.Tests/MeterFactoryTests.cs

@@ -1,7 +1,7 @@
 // Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
-using OpenTelemetry.Trace;
+using OpenTelemetry.Metrics;
 using Xunit;
 
 namespace OpenTelemetry.Instrumentation.Tests;