Add ExtendedLogRecordBuilder#setException, make exception.* resolution configurable

Author: jack-berg

api/incubator/src/main/java/io/opentelemetry/api/incubator/logs/ExtendedDefaultLogger.java

@@ -40,6 +40,11 @@ public ExtendedLogRecordBuilder setEventName(String eventName) {
       return this;
     }
 
+    @Override
+    public ExtendedLogRecordBuilder setException(Throwable throwable) {
+      return this;
+    }
+
     @Override
     public LogRecordBuilder setTimestamp(long timestamp, TimeUnit unit) {
       return this;

api/incubator/src/main/java/io/opentelemetry/api/incubator/logs/ExtendedLogRecordBuilder.java

@@ -19,4 +19,7 @@ public interface ExtendedLogRecordBuilder extends LogRecordBuilder {
    * record with a non-empty event name is an Event.
    */
   ExtendedLogRecordBuilder setEventName(String eventName);
+
+  /** Set standard {@code exception.*} attributes based on the {@code throwable}. */
+  ExtendedLogRecordBuilder setException(Throwable throwable);
 }

buildSrc/src/main/kotlin/otel.java-conventions.gradle.kts

@@ -87,9 +87,7 @@ tasks {
             // https://groups.google.com/forum/#!topic/bazel-discuss/_R3A9TJSoPM
             "-Xlint:-processing",
             // We suppress the "options" warning because it prevents compilation on modern JDKs
-            "-Xlint:-options",
-            // Fail build on any warning
-            "-Werror",
+            "-Xlint:-options"
           ),
         )
       }

sdk/common/src/main/java/io/opentelemetry/sdk/internal/DefaultExceptionAttributeResolver.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.internal;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import javax.annotation.Nullable;
+
+/**
+ * This class is internal and experimental. Its APIs are unstable and can change at any time. Its
+ * APIs (or a version of them) may be promoted to the public stable API in the future, but no
+ * guarantees are made.
+ */
+public final class DefaultExceptionAttributeResolver implements ExceptionAttributeResolver {
+
+  private static final DefaultExceptionAttributeResolver INSTANCE =
+      new DefaultExceptionAttributeResolver();
+
+  private DefaultExceptionAttributeResolver() {}
+
+  public static ExceptionAttributeResolver getInstance() {
+    return INSTANCE;
+  }
+
+  @Override
+  @Nullable
+  public String getExceptionType(Throwable throwable) {
+    return throwable.getClass().getCanonicalName();
+  }
+
+  @Override
+  @Nullable
+  public String getExceptionMessage(Throwable throwable) {
+    return throwable.getMessage();
+  }
+
+  @Override
+  @Nullable
+  public String getExceptionStacktrace(Throwable throwable) {
+    StringWriter stringWriter = new StringWriter();
+    try (PrintWriter printWriter = new PrintWriter(stringWriter)) {
+      throwable.printStackTrace(printWriter);
+    }
+    return stringWriter.toString();
+  }
+}

sdk/common/src/main/java/io/opentelemetry/sdk/internal/ExceptionAttributeResolver.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.internal;
+
+import io.opentelemetry.api.common.AttributeKey;
+import javax.annotation.Nullable;
+
+/**
+ * Implementations resolve {@code exception.*} attributes attached to span events, logs, etc.
+ *
+ * <p>This class is internal and experimental. Its APIs are unstable and can change at any time. Its
+ * APIs (or a version of them) may be promoted to the public stable API in the future, but no
+ * guarantees are made.
+ */
+public interface ExceptionAttributeResolver {
+
+  AttributeKey<String> EXCEPTION_TYPE = AttributeKey.stringKey("exception.type");
+  AttributeKey<String> EXCEPTION_MESSAGE = AttributeKey.stringKey("exception.message");
+  AttributeKey<String> EXCEPTION_STACKTRACE = AttributeKey.stringKey("exception.stacktrace");
+
+  /**
+   * Resolve the {@link #EXCEPTION_TYPE} attribute from the {@code throwable}, or {@code null} if no
+   * value should be set.
+   */
+  @Nullable
+  String getExceptionType(Throwable throwable);
+
+  /**
+   * Resolve the {@link #EXCEPTION_MESSAGE} attribute from the {@code throwable}, or {@code null} if
+   * no value should be set.
+   */
+  @Nullable
+  String getExceptionMessage(Throwable throwable);
+
+  /**
+   * Resolve the {@link #EXCEPTION_STACKTRACE} attribute from the {@code throwable}, or {@code null}
+   * if no value should be set.
+   */
+  @Nullable
+  String getExceptionStacktrace(Throwable throwable);
+}

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

@@ -29,6 +29,12 @@ public ExtendedSdkLogRecordBuilder setEventName(String eventName) {
     return this;
   }
 
+  @Override
+  public ExtendedSdkLogRecordBuilder setException(Throwable throwable) {
+    super.setException(throwable);
+    return this;
+  }
+
   @Override
   public ExtendedSdkLogRecordBuilder setTimestamp(long timestamp, TimeUnit unit) {
     super.setTimestamp(timestamp, unit);

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

@@ -7,6 +7,7 @@
 
 import io.opentelemetry.sdk.common.Clock;
 import io.opentelemetry.sdk.common.CompletableResultCode;
+import io.opentelemetry.sdk.internal.ExceptionAttributeResolver;
 import io.opentelemetry.sdk.resources.Resource;
 import java.util.function.Supplier;
 import javax.annotation.Nullable;
@@ -21,17 +22,20 @@ final class LoggerSharedState {
   private final Supplier<LogLimits> logLimitsSupplier;
   private final LogRecordProcessor logRecordProcessor;
   private final Clock clock;
+  private final ExceptionAttributeResolver exceptionAttributeResolver;
   @Nullable private volatile CompletableResultCode shutdownResult = null;
 
   LoggerSharedState(
       Resource resource,
       Supplier<LogLimits> logLimitsSupplier,
       LogRecordProcessor logRecordProcessor,
-      Clock clock) {
+      Clock clock,
+      ExceptionAttributeResolver exceptionAttributeResolver) {
     this.resource = resource;
     this.logLimitsSupplier = logLimitsSupplier;
     this.logRecordProcessor = logRecordProcessor;
     this.clock = clock;
+    this.exceptionAttributeResolver = exceptionAttributeResolver;
   }
 
   Resource getResource() {
@@ -50,6 +54,10 @@ Clock getClock() {
     return clock;
   }
 
+  ExceptionAttributeResolver getExceptionAttributeResolver() {
+    return exceptionAttributeResolver;
+  }
+
   boolean hasBeenShutdown() {
     return shutdownResult != null;
   }

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

@@ -5,6 +5,10 @@
 
 package io.opentelemetry.sdk.logs;
 
+import static io.opentelemetry.sdk.internal.ExceptionAttributeResolver.EXCEPTION_MESSAGE;
+import static io.opentelemetry.sdk.internal.ExceptionAttributeResolver.EXCEPTION_STACKTRACE;
+import static io.opentelemetry.sdk.internal.ExceptionAttributeResolver.EXCEPTION_TYPE;
+
 import io.opentelemetry.api.common.AttributeKey;
 import io.opentelemetry.api.common.Value;
 import io.opentelemetry.api.logs.LogRecordBuilder;
@@ -13,6 +17,7 @@
 import io.opentelemetry.context.Context;
 import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
 import io.opentelemetry.sdk.internal.AttributesMap;
+import io.opentelemetry.sdk.internal.ExceptionAttributeResolver;
 import java.time.Instant;
 import java.util.concurrent.TimeUnit;
 import javax.annotation.Nullable;
@@ -46,6 +51,28 @@ SdkLogRecordBuilder setEventName(String eventName) {
     return this;
   }
 
+  // accessible via ExtendedSdkLogRecordBuilder
+  SdkLogRecordBuilder setException(Throwable throwable) {
+    if (throwable == null) {
+      return this;
+    }
+    ExceptionAttributeResolver exceptionAttributeResolver =
+        loggerSharedState.getExceptionAttributeResolver();
+    String type = exceptionAttributeResolver.getExceptionType(throwable);
+    if (type != null) {
+      setAttribute(EXCEPTION_TYPE, type);
+    }
+    String message = exceptionAttributeResolver.getExceptionMessage(throwable);
+    if (message != null) {
+      setAttribute(EXCEPTION_MESSAGE, message);
+    }
+    String stacktrace = exceptionAttributeResolver.getExceptionStacktrace(throwable);
+    if (stacktrace != null) {
+      setAttribute(EXCEPTION_STACKTRACE, stacktrace);
+    }
+    return this;
+  }
+
   @Override
   public SdkLogRecordBuilder setTimestamp(long timestamp, TimeUnit unit) {
     this.timestampEpochNanos = unit.toNanos(timestamp);

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

@@ -13,6 +13,7 @@
 import io.opentelemetry.sdk.common.CompletableResultCode;
 import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
 import io.opentelemetry.sdk.internal.ComponentRegistry;
+import io.opentelemetry.sdk.internal.ExceptionAttributeResolver;
 import io.opentelemetry.sdk.internal.ScopeConfigurator;
 import io.opentelemetry.sdk.logs.internal.LoggerConfig;
 import io.opentelemetry.sdk.resources.Resource;
@@ -53,10 +54,12 @@ public static SdkLoggerProviderBuilder builder() {
       Supplier<LogLimits> logLimitsSupplier,
       List<LogRecordProcessor> processors,
       Clock clock,
-      ScopeConfigurator<LoggerConfig> loggerConfigurator) {
+      ScopeConfigurator<LoggerConfig> loggerConfigurator,
+      ExceptionAttributeResolver exceptionAttributeResolver) {
     LogRecordProcessor logRecordProcessor = LogRecordProcessor.composite(processors);
     this.sharedState =
-        new LoggerSharedState(resource, logLimitsSupplier, logRecordProcessor, clock);
+        new LoggerSharedState(
+            resource, logLimitsSupplier, logRecordProcessor, clock, exceptionAttributeResolver);
     this.loggerComponentRegistry =
         new ComponentRegistry<>(
             instrumentationScopeInfo ->

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

@@ -12,6 +12,8 @@
 import io.opentelemetry.context.Context;
 import io.opentelemetry.sdk.common.Clock;
 import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
+import io.opentelemetry.sdk.internal.DefaultExceptionAttributeResolver;
+import io.opentelemetry.sdk.internal.ExceptionAttributeResolver;
 import io.opentelemetry.sdk.internal.ScopeConfigurator;
 import io.opentelemetry.sdk.internal.ScopeConfiguratorBuilder;
 import io.opentelemetry.sdk.logs.data.LogRecordData;
@@ -37,6 +39,8 @@ public final class SdkLoggerProviderBuilder {
   private Clock clock = Clock.getDefault();
   private ScopeConfiguratorBuilder<LoggerConfig> loggerConfiguratorBuilder =
       LoggerConfig.configuratorBuilder();
+  private ExceptionAttributeResolver exceptionAttributeResolver =
+      DefaultExceptionAttributeResolver.getInstance();
 
   SdkLoggerProviderBuilder() {}
 
@@ -149,13 +153,33 @@ SdkLoggerProviderBuilder addLoggerConfiguratorCondition(
     return this;
   }
 
+  /**
+   * Set the exception attribute resolver, which resolves {@code exception.*} attributes an
+   * exception is set on a log.
+   *
+   * <p>This method is experimental so not public. You may reflectively call it using {@link
+   * SdkLoggerProviderUtil#setExceptionAttributeResolver(SdkLoggerProviderBuilder,
+   * ExceptionAttributeResolver)}.
+   */
+  SdkLoggerProviderBuilder setExceptionAttributeResolver(
+      ExceptionAttributeResolver exceptionAttributeResolver) {
+    requireNonNull(exceptionAttributeResolver, "exceptionAttributeResolver");
+    this.exceptionAttributeResolver = exceptionAttributeResolver;
+    return this;
+  }
+
   /**
    * Create a {@link SdkLoggerProvider} instance.
    *
    * @return an instance configured with the provided options
    */
   public SdkLoggerProvider build() {
     return new SdkLoggerProvider(
-        resource, logLimitsSupplier, logRecordProcessors, clock, loggerConfiguratorBuilder.build());
+        resource,
+        logLimitsSupplier,
+        logRecordProcessors,
+        clock,
+        loggerConfiguratorBuilder.build(),
+        exceptionAttributeResolver);
   }
 }