Adding an override to LoggerProvider.GetLogger

src/OpenTelemetry.Api/.publicApi/Stable/PublicAPI.Unshipped.txt

@@ -1,0 +1,2 @@
+OpenTelemetry.Logs.Logger.Attributes.get -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string!, object?>>?
+OpenTelemetry.Logs.LoggerProvider.GetLogger(string? name, string? version, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string!, object?>>? attributes) -> OpenTelemetry.Logs.Logger!

src/OpenTelemetry.Api/Logs/Logger.cs

@@ -46,6 +46,11 @@ protected Logger(string? name)
     /// </summary>
     public string? Version { get; private set; }
 
+    /// <summary>
+    /// Gets the attributes of the instrumentation library.
+    /// </summary>
+    public IEnumerable<KeyValuePair<string, object?>>? Attributes { get; private set; }
+
     /// <summary>
     /// Emit a log.
     /// </summary>
@@ -63,8 +68,10 @@ public abstract void EmitLog(
         in LogRecordAttributeList attributes);
 
     internal void SetInstrumentationScope(
-        string? version)
+        string? version,
+        IEnumerable<KeyValuePair<string, object?>>? attributes)
     {
         this.Version = version;
+        this.Attributes = attributes;
     }
 }

src/OpenTelemetry.Api/Logs/LoggerProvider.cs

@@ -38,7 +38,7 @@ protected LoggerProvider()
     internal
 #endif
         Logger GetLogger()
-        => this.GetLogger(name: null, version: null);
+        => this.GetLogger(name: null, version: null, attributes: null);
 
 #if EXPOSE_EXPERIMENTAL_FEATURES
     /// <summary>
@@ -55,7 +55,7 @@ Logger GetLogger()
     internal
 #endif
         Logger GetLogger(string? name)
-        => this.GetLogger(name, version: null);
+        => this.GetLogger(name, version: null, attributes: null);
 
 #if EXPOSE_EXPERIMENTAL_FEATURES
     /// <summary>
@@ -73,13 +73,32 @@ Logger GetLogger(string? name)
     internal
 #endif
         Logger GetLogger(string? name, string? version)
+        => this.GetLogger(name, version, attributes: null);
+
+#if EXPOSE_EXPERIMENTAL_FEATURES
+    /// <summary>
+    /// Gets a logger with the given name and version.
+    /// </summary>
+    /// <remarks><inheritdoc cref="Logger" path="/remarks"/></remarks>
+    /// <param name="name">Optional name identifying the instrumentation library.</param>
+    /// <param name="version">Optional version of the instrumentation library.</param>
+    /// <param name="attributes">Optional instrumentation scope attributes.</param>
+    /// <returns><see cref="Logger"/> instance.</returns>
+#if NET
+    [Experimental(DiagnosticDefinitions.LogsBridgeExperimentalApi, UrlFormat = DiagnosticDefinitions.ExperimentalApiUrlFormat)]
+#endif
+    public
+#else
+    internal
+#endif
+        Logger GetLogger(string? name, string? version, IEnumerable<KeyValuePair<string, object?>>? attributes)
     {
         if (!this.TryCreateLogger(name, out var logger))
         {
             return NoopLogger;
         }
 
-        logger!.SetInstrumentationScope(version);
+        logger!.SetInstrumentationScope(version, attributes);
 
         return logger;
     }

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/Serializer/ProtobufOtlpLogSerializer.cs

@@ -125,23 +125,96 @@ internal static int WriteScopeLogs(byte[] buffer, int writePosition, SdkLimitOpt
                 int resourceLogsScopeLogsLengthPosition = writePosition;
                 writePosition += ReserveSizeForLength;
 
-                writePosition = WriteScopeLog(buffer, writePosition, sdkLimitOptions, experimentalOptions, entry.Value[0].Logger.Name, entry.Value);
+                writePosition = WriteScopeLog(buffer, writePosition, sdkLimitOptions, experimentalOptions, entry.Value[0].Logger, entry.Value);
                 ProtobufSerializer.WriteReservedLength(buffer, resourceLogsScopeLogsLengthPosition, writePosition - (resourceLogsScopeLogsLengthPosition + ReserveSizeForLength));
             }
         }
 
         return writePosition;
     }
 
-    internal static int WriteScopeLog(byte[] buffer, int writePosition, SdkLimitOptions sdkLimitOptions, ExperimentalOptions experimentalOptions, string loggerName, List<LogRecord> logRecords)
+    internal static int WriteScopeLog(byte[] buffer, int writePosition, SdkLimitOptions sdkLimitOptions, ExperimentalOptions experimentalOptions, Logger logger, List<LogRecord> logRecords)
     {
-        var value = loggerName.AsSpan();
-        var numberOfUtf8CharsInString = ProtobufSerializer.GetNumberOfUtf8CharsInString(value);
-        var serializedLengthSize = ProtobufSerializer.ComputeVarInt64Size((ulong)numberOfUtf8CharsInString);
+        var value = logger.Name.AsSpan();
+
+        writePosition = ProtobufSerializer.WriteTag(buffer, writePosition, ProtobufOtlpLogFieldNumberConstants.ScopeLogs_Scope, ProtobufWireType.LEN);
+        int instrumentationScopeLengthPosition = writePosition;
+        writePosition += ReserveSizeForLength;
+
+        writePosition = ProtobufSerializer.WriteStringWithTag(buffer, writePosition, ProtobufOtlpCommonFieldNumberConstants.InstrumentationScope_Name, value);
+
+        if (logger.Version != null)
+        {
+            writePosition = ProtobufSerializer.WriteStringWithTag(buffer, writePosition, ProtobufOtlpCommonFieldNumberConstants.InstrumentationScope_Version, logger.Version);
+        }
+
+        if (logger.Attributes != null)
+        {
+            var maxAttributeCount = sdkLimitOptions.LogRecordAttributeCountLimit ?? int.MaxValue;
+            var maxAttributeValueLength = sdkLimitOptions.LogRecordAttributeValueLengthLimit ?? int.MaxValue;
+            ProtobufOtlpTagWriter.OtlpTagWriterState otlpTagWriterState = new ProtobufOtlpTagWriter.OtlpTagWriterState
+            {
+                Buffer = buffer,
+                WritePosition = writePosition,
+                TagCount = 0,
+                DroppedTagCount = 0,
+            };
+
+            if (logger.Attributes is IReadOnlyList<KeyValuePair<string, object?>> attributes)
+            {
+                for (int i = 0; i < attributes.Count; i++)
+                {
+                    if (otlpTagWriterState.TagCount < maxAttributeCount)
+                    {
+                        otlpTagWriterState.WritePosition = ProtobufSerializer.WriteTag(otlpTagWriterState.Buffer, otlpTagWriterState.WritePosition, ProtobufOtlpCommonFieldNumberConstants.InstrumentationScope_Attributes, ProtobufWireType.LEN);
+                        int instrumentationScopeAttributesLengthPosition = otlpTagWriterState.WritePosition;
+                        otlpTagWriterState.WritePosition += ReserveSizeForLength;
+
+                        ProtobufOtlpTagWriter.Instance.TryWriteTag(ref otlpTagWriterState, attributes[i].Key, attributes[i].Value, maxAttributeValueLength);
+
+                        var instrumentationScopeAttributesLength = otlpTagWriterState.WritePosition - (instrumentationScopeAttributesLengthPosition + ReserveSizeForLength);
+                        ProtobufSerializer.WriteReservedLength(otlpTagWriterState.Buffer, instrumentationScopeAttributesLengthPosition, instrumentationScopeAttributesLength);
+                        otlpTagWriterState.TagCount++;
+                    }
+                    else
+                    {
+                        otlpTagWriterState.DroppedTagCount++;
+                    }
+                }
+            }
+            else
+            {
+                foreach (var attribute in logger.Attributes)
+                {
+                    if (otlpTagWriterState.TagCount < maxAttributeCount)
+                    {
+                        otlpTagWriterState.WritePosition = ProtobufSerializer.WriteTag(otlpTagWriterState.Buffer, otlpTagWriterState.WritePosition, ProtobufOtlpCommonFieldNumberConstants.InstrumentationScope_Attributes, ProtobufWireType.LEN);
+                        int instrumentationScopeAttributesLengthPosition = otlpTagWriterState.WritePosition;
+                        otlpTagWriterState.WritePosition += ReserveSizeForLength;
+
+                        ProtobufOtlpTagWriter.Instance.TryWriteTag(ref otlpTagWriterState, attribute.Key, attribute.Value, maxAttributeValueLength);
+
+                        var instrumentationScopeAttributesLength = otlpTagWriterState.WritePosition - (instrumentationScopeAttributesLengthPosition + ReserveSizeForLength);
+                        ProtobufSerializer.WriteReservedLength(otlpTagWriterState.Buffer, instrumentationScopeAttributesLengthPosition, instrumentationScopeAttributesLength);
+                        otlpTagWriterState.TagCount++;
+                    }
+                    else
+                    {
+                        otlpTagWriterState.DroppedTagCount++;
+                    }
+                }
+            }
+
+            if (otlpTagWriterState.DroppedTagCount > 0)
+            {
+                otlpTagWriterState.WritePosition = ProtobufSerializer.WriteTag(buffer, otlpTagWriterState.WritePosition, ProtobufOtlpCommonFieldNumberConstants.InstrumentationScope_Dropped_Attributes_Count, ProtobufWireType.VARINT);
+                otlpTagWriterState.WritePosition = ProtobufSerializer.WriteVarInt32(buffer, otlpTagWriterState.WritePosition, (uint)otlpTagWriterState.DroppedTagCount);
+            }
+
+            writePosition = otlpTagWriterState.WritePosition;
+        }
 
-        // numberOfUtf8CharsInString + tagSize + length field size.
-        writePosition = ProtobufSerializer.WriteTagAndLength(buffer, writePosition, numberOfUtf8CharsInString + 1 + serializedLengthSize, ProtobufOtlpLogFieldNumberConstants.ScopeLogs_Scope, ProtobufWireType.LEN);
-        writePosition = ProtobufSerializer.WriteStringWithTag(buffer, writePosition, ProtobufOtlpCommonFieldNumberConstants.InstrumentationScope_Name, numberOfUtf8CharsInString, value);
+        ProtobufSerializer.WriteReservedLength(buffer, instrumentationScopeLengthPosition, writePosition - (instrumentationScopeLengthPosition + ReserveSizeForLength));
 
         for (int i = 0; i < logRecords.Count; i++)
         {

test/OpenTelemetry.Exporter.OpenTelemetryProtocol.Tests/OtlpLogExporterTests.cs

@@ -1497,6 +1497,94 @@ public void LogSerialization_ExpandsBufferForLogsAndSerializes()
         Assert.Equal("MyLogger", request.ResourceLogs[0].ScopeLogs[0].Scope?.Name);
     }
 
+    [Theory]
+    [InlineData(true, true)]
+    [InlineData(true, false)]
+    [InlineData(false, true)]
+    [InlineData(false, false)]
+    public void InstrumentationScopeVersionAndAttributesAreExported(bool includeVersion, bool includeAttributes)
+    {
+        var version = "1.0.0";
+        var loggerName = "MyLogger";
+
+        var instrumentationScopeAttributes = new List<KeyValuePair<string, object?>>
+        {
+            new("a", "x"),
+            new("b", 1),
+            new("c", true),
+        };
+
+        var logRecords = new List<LogRecord>();
+
+        using (var loggerProvider = Sdk.CreateLoggerProviderBuilder()
+                   .AddInMemoryExporter(logRecords)
+                   .Build())
+        {
+            Logger? logger;
+
+            if (includeVersion && includeAttributes)
+            {
+                logger = loggerProvider.GetLogger(loggerName, version, instrumentationScopeAttributes);
+            }
+            else if (includeVersion && !includeAttributes)
+            {
+                logger = loggerProvider.GetLogger(loggerName, version);
+            }
+            else if (!includeVersion && includeAttributes)
+            {
+                logger = loggerProvider.GetLogger(loggerName, null, instrumentationScopeAttributes);
+            }
+            else
+            {
+                logger = loggerProvider.GetLogger(loggerName);
+            }
+
+            logger.EmitLog(new LogRecordData());
+        }
+
+        Assert.Single(logRecords);
+
+        var batch = new Batch<LogRecord>(logRecords.ToArray(), logRecords.Count);
+        var resourceBuilder = ResourceBuilder.CreateEmpty();
+
+        OtlpCollector.ExportLogsServiceRequest request = CreateLogsExportRequest(DefaultSdkLimitOptions, new ExperimentalOptions(), batch, resourceBuilder.Build());
+
+        Assert.Equal(loggerName, request.ResourceLogs[0].ScopeLogs[0].Scope?.Name);
+
+        if (includeVersion)
+        {
+            Assert.Equal(version, request.ResourceLogs[0].ScopeLogs[0].Scope?.Version);
+        }
+        else
+        {
+            Assert.Equal(string.Empty, request.ResourceLogs[0].ScopeLogs[0].Scope?.Version);
+        }
+
+        if (includeAttributes)
+        {
+            Assert.Equal(instrumentationScopeAttributes.Count, request.ResourceLogs[0].ScopeLogs[0].Scope?.Attributes.Count);
+
+            var index = 0;
+
+            Assert.Equal(instrumentationScopeAttributes[index].Key, request.ResourceLogs[0].ScopeLogs[0].Scope?.Attributes[index].Key);
+            Assert.Equal(instrumentationScopeAttributes[index].Value, request.ResourceLogs[0].ScopeLogs[0].Scope?.Attributes[index].Value.StringValue);
+
+            index++;
+
+            Assert.Equal(instrumentationScopeAttributes[index].Key, request.ResourceLogs[0].ScopeLogs[0].Scope?.Attributes[index].Key);
+            Assert.Equal(instrumentationScopeAttributes[index].Value, (int?)request.ResourceLogs[0].ScopeLogs[0].Scope?.Attributes[index].Value.IntValue);
+
+            index++;
+
+            Assert.Equal(instrumentationScopeAttributes[index].Key, request.ResourceLogs[0].ScopeLogs[0].Scope?.Attributes[index].Key);
+            Assert.Equal(instrumentationScopeAttributes[index].Value, request.ResourceLogs[0].ScopeLogs[0].Scope?.Attributes[index].Value.BoolValue);
+        }
+        else
+        {
+            Assert.Empty(request.ResourceLogs[0].ScopeLogs[0].Scope?.Attributes!);
+        }
+    }
+
     private static void RunVerifyEnvironmentVariablesTakenFromIConfigurationTest(
         string? optionsName,
         Func<Action<IServiceCollection>, (IDisposable Container, ILoggerFactory LoggerFactory)> createLoggerFactoryFunc)