Implement SDK metrics for logs

docs/apidiffs/current_vs_latest/opentelemetry-sdk-logs.txt

@@ -1,2 +1,16 @@
 Comparing source compatibility of opentelemetry-sdk-logs-1.58.0-SNAPSHOT.jar against opentelemetry-sdk-logs-1.57.0.jar
-No changes.
+***  MODIFIED CLASS: PUBLIC FINAL io.opentelemetry.sdk.logs.export.BatchLogRecordProcessorBuilder  (not serializable)
+	===  CLASS FILE FORMAT VERSION: 52.0 <- 52.0
+	+++  NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.export.BatchLogRecordProcessorBuilder setInternalTelemetryVersion(io.opentelemetry.sdk.common.InternalTelemetryVersion)
+	+++  NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.export.BatchLogRecordProcessorBuilder setMeterProvider(java.util.function.Supplier<io.opentelemetry.api.metrics.MeterProvider>)
+***  MODIFIED CLASS: PUBLIC FINAL io.opentelemetry.sdk.logs.export.SimpleLogRecordProcessor  (not serializable)
+	===  CLASS FILE FORMAT VERSION: 52.0 <- 52.0
+	+++  NEW METHOD: PUBLIC(+) STATIC(+) io.opentelemetry.sdk.logs.export.SimpleLogRecordProcessorBuilder builder(io.opentelemetry.sdk.logs.export.LogRecordExporter)
++++  NEW CLASS: PUBLIC(+) FINAL(+) io.opentelemetry.sdk.logs.export.SimpleLogRecordProcessorBuilder  (not serializable)
+	+++  CLASS FILE FORMAT VERSION: 52.0 <- n.a.
+	+++  NEW SUPERCLASS: java.lang.Object
+	+++  NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.export.SimpleLogRecordProcessor build()
+	+++  NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.export.SimpleLogRecordProcessorBuilder setMeterProvider(java.util.function.Supplier<io.opentelemetry.api.metrics.MeterProvider>)
+***  MODIFIED CLASS: PUBLIC FINAL io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder  (not serializable)
+	===  CLASS FILE FORMAT VERSION: 52.0 <- 52.0
+	+++  NEW METHOD: PUBLIC(+) io.opentelemetry.sdk.logs.SdkLoggerProviderBuilder setMeterProvider(java.util.function.Supplier<io.opentelemetry.api.metrics.MeterProvider>)

sdk-extensions/autoconfigure/src/main/java/io/opentelemetry/sdk/autoconfigure/LoggerProviderConfiguration.java

@@ -44,6 +44,7 @@ static void configureLoggerProvider(
       List<Closeable> closeables) {
 
     loggerProviderBuilder.setLogLimits(() -> configureLogLimits(config));
+    loggerProviderBuilder.setMeterProvider(() -> meterProvider);
 
     Map<String, LogRecordExporter> exportersByName =
         configureLogRecordExporters(config, spiHelper, logRecordExporterCustomizer, closeables);
@@ -71,7 +72,10 @@ static List<LogRecordProcessor> configureLogRecordProcessors(
     for (String simpleProcessorExporterName : simpleProcessorExporterNames) {
       LogRecordExporter exporter = exportersByNameCopy.remove(simpleProcessorExporterName);
       if (exporter != null) {
-        LogRecordProcessor logRecordProcessor = SimpleLogRecordProcessor.create(exporter);
+        LogRecordProcessor logRecordProcessor =
+            SimpleLogRecordProcessor.builder(exporter)
+                .setMeterProvider(() -> meterProvider)
+                .build();
         closeables.add(logRecordProcessor);
         logRecordProcessors.add(logRecordProcessor);
       }

sdk-extensions/incubator/src/main/java/io/opentelemetry/sdk/extension/incubator/fileconfig/LogRecordProcessorFactory.java

@@ -68,7 +68,11 @@ public LogRecordProcessor create(
               simpleModel.getExporter(), "simple log record processor exporter");
       LogRecordExporter logRecordExporter =
           LogRecordExporterFactory.getInstance().create(exporterModel, context);
-      return context.addCloseable(SimpleLogRecordProcessor.create(logRecordExporter));
+      MeterProvider meterProvider = context.getMeterProvider();
+      return context.addCloseable(
+          SimpleLogRecordProcessor.builder(logRecordExporter)
+              .setMeterProvider(() -> meterProvider)
+              .build());
     }
 
     Map.Entry<String, Object> keyValue =

sdk-extensions/incubator/src/test/java/io/opentelemetry/sdk/extension/incubator/fileconfig/OpenTelemetryConfigurationFactoryTest.java

@@ -325,17 +325,17 @@ void create_Configured() throws NoSuchFieldException, IllegalAccessException {
     // test that the meter provider is wired through to the tracer and logger providers
     Field field = SdkMeterProvider.class.getDeclaredField("sharedState");
     field.setAccessible(true);
-    Object sharedState = field.get(sdk.getSdkMeterProvider());
+
+    // Lazily initialized
     assertThat(sdk)
         .extracting("loggerProvider")
         .extracting("delegate")
         .extracting("sharedState")
         .extracting("logRecordProcessor")
         .extracting("worker")
-        .extracting("processedLogsCounter")
-        .extracting("sdkMeter")
-        .extracting("meterProviderSharedState")
-        .isEqualTo(sharedState);
+        .extracting("logProcessorInstrumentation")
+        .extracting("processedLogs")
+        .isNull();
 
     // Lazily initialized
     assertThat(sdk)

sdk/logs/src/main/java/io/opentelemetry/sdk/logs/LoggerSharedState.java

@@ -23,19 +23,22 @@ final class LoggerSharedState {
   private final LogRecordProcessor logRecordProcessor;
   private final Clock clock;
   private final ExceptionAttributeResolver exceptionAttributeResolver;
+  private final SdkLoggerInstrumentation loggerInstrumentation;
   @Nullable private volatile CompletableResultCode shutdownResult = null;
 
   LoggerSharedState(
       Resource resource,
       Supplier<LogLimits> logLimitsSupplier,
       LogRecordProcessor logRecordProcessor,
       Clock clock,
-      ExceptionAttributeResolver exceptionAttributeResolver) {
+      ExceptionAttributeResolver exceptionAttributeResolver,
+      SdkLoggerInstrumentation loggerInstrumentation) {
     this.resource = resource;
     this.logLimitsSupplier = logLimitsSupplier;
     this.logRecordProcessor = logRecordProcessor;
     this.clock = clock;
     this.exceptionAttributeResolver = exceptionAttributeResolver;
+    this.loggerInstrumentation = loggerInstrumentation;
   }
 
   Resource getResource() {
@@ -58,6 +61,10 @@ ExceptionAttributeResolver getExceptionAttributeResolver() {
     return exceptionAttributeResolver;
   }
 
+  SdkLoggerInstrumentation getLoggerInstrumentation() {
+    return loggerInstrumentation;
+  }
+
   boolean hasBeenShutdown() {
     return shutdownResult != null;
   }

sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLogRecordBuilder.java

@@ -132,6 +132,8 @@ public void emit() {
         this.observedTimestampEpochNanos == 0
             ? this.loggerSharedState.getClock().now()
             : this.observedTimestampEpochNanos;
+
+    loggerSharedState.getLoggerInstrumentation().emitLog();
     loggerSharedState
         .getLogRecordProcessor()
         .onEmit(context, createLogRecord(context, observedTimestampEpochNanos));

sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLoggerInstrumentation.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.logs;
+
+import io.opentelemetry.api.metrics.LongCounter;
+import io.opentelemetry.api.metrics.Meter;
+import io.opentelemetry.api.metrics.MeterProvider;
+import java.util.function.Supplier;
+import javax.annotation.Nullable;
+
+/**
+ * SDK metrics exported for emitted logs as defined in the <a
+ * href="https://opentelemetry.io/docs/specs/semconv/otel/sdk-metrics/#log-metrics">semantic
+ * conventions</a>.
+ */
+final class SdkLoggerInstrumentation {
+  private final Object lock = new Object();
+
+  private final Supplier<MeterProvider> meterProvider;
+
+  @Nullable private Meter meter;
+  @Nullable private volatile LongCounter createdLogs;
+
+  SdkLoggerInstrumentation(Supplier<MeterProvider> meterProvider) {
+    this.meterProvider = meterProvider;
+  }
+
+  void emitLog() {
+    createdLogs().add(1);
+  }
+
+  private LongCounter createdLogs() {
+    LongCounter createdLogs = this.createdLogs;
+    if (createdLogs == null) {
+      synchronized (lock) {
+        createdLogs = this.createdLogs;
+        if (createdLogs == null) {
+          createdLogs =
+              meter()
+                  .counterBuilder("otel.sdk.log.created")
+                  .setUnit("{log_record}")
+                  .setDescription("The number of logs submitted to enabled SDK Loggers.")
+                  .build();
+          this.createdLogs = createdLogs;
+        }
+      }
+    }
+    return createdLogs;
+  }
+
+  private Meter meter() {
+    if (meter == null) {
+      // Safe to call from multiple threads.
+      meter = meterProvider.get().get("io.opentelemetry.sdk.logs");
+    }
+    return meter;
+  }
+}

sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLoggerProvider.java

@@ -9,6 +9,7 @@
 import io.opentelemetry.api.logs.Logger;
 import io.opentelemetry.api.logs.LoggerBuilder;
 import io.opentelemetry.api.logs.LoggerProvider;
+import io.opentelemetry.api.metrics.MeterProvider;
 import io.opentelemetry.sdk.common.Clock;
 import io.opentelemetry.sdk.common.CompletableResultCode;
 import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
@@ -58,11 +59,17 @@ public static SdkLoggerProviderBuilder builder() {
       List<LogRecordProcessor> processors,
       Clock clock,
       ScopeConfigurator<LoggerConfig> loggerConfigurator,
-      ExceptionAttributeResolver exceptionAttributeResolver) {
+      ExceptionAttributeResolver exceptionAttributeResolver,
+      Supplier<MeterProvider> meterProvider) {
     LogRecordProcessor logRecordProcessor = LogRecordProcessor.composite(processors);
     this.sharedState =
         new LoggerSharedState(
-            resource, logLimitsSupplier, logRecordProcessor, clock, exceptionAttributeResolver);
+            resource,
+            logLimitsSupplier,
+            logRecordProcessor,
+            clock,
+            exceptionAttributeResolver,
+            new SdkLoggerInstrumentation(meterProvider));
     this.loggerComponentRegistry =
         new ComponentRegistry<>(
             instrumentationScopeInfo ->

sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLoggerProviderBuilder.java

@@ -9,6 +9,7 @@
 
 import io.opentelemetry.api.logs.LogRecordBuilder;
 import io.opentelemetry.api.logs.Logger;
+import io.opentelemetry.api.metrics.MeterProvider;
 import io.opentelemetry.context.Context;
 import io.opentelemetry.sdk.common.Clock;
 import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
@@ -40,6 +41,7 @@ public final class SdkLoggerProviderBuilder {
       LoggerConfig.configuratorBuilder();
   private ExceptionAttributeResolver exceptionAttributeResolver =
       ExceptionAttributeResolver.getDefault();
+  private Supplier<MeterProvider> meterProvider = MeterProvider::noop;
 
   SdkLoggerProviderBuilder() {}
 
@@ -186,6 +188,17 @@ SdkLoggerProviderBuilder setExceptionAttributeResolver(
     return this;
   }
 
+  /**
+   * Sets the {@link MeterProvider} to use to generate <a
+   * href="https://opentelemetry.io/docs/specs/semconv/otel/sdk-metrics/#span-metrics">SDK Span
+   * Metrics</a>.
+   */
+  public SdkLoggerProviderBuilder setMeterProvider(Supplier<MeterProvider> meterProvider) {
+    requireNonNull(meterProvider, "meterProvider");
+    this.meterProvider = meterProvider;
+    return this;
+  }
+
   /**
    * Create a {@link SdkLoggerProvider} instance.
    *
@@ -198,6 +211,7 @@ public SdkLoggerProvider build() {
         logRecordProcessors,
         clock,
         loggerConfiguratorBuilder.build(),
-        exceptionAttributeResolver);
+        exceptionAttributeResolver,
+        meterProvider);
   }
 }