Add property to render stacktrace using jvm default

Author: jack-berg

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

@@ -5,6 +5,7 @@
 
 package io.opentelemetry.sdk.internal;
 
+import io.opentelemetry.api.internal.ConfigUtil;
 import java.io.PrintWriter;
 import java.io.StringWriter;
 
@@ -15,10 +16,19 @@
  */
 public final class DefaultExceptionAttributeResolver implements ExceptionAttributeResolver {
 
+  private static final String ENABLE_JVM_STACKTRACE_PROPERTY =
+      "otel.experimental.sdk.jvm_stacktrace";
+
   private static final DefaultExceptionAttributeResolver INSTANCE =
-      new DefaultExceptionAttributeResolver();
+      new DefaultExceptionAttributeResolver(
+          Boolean.parseBoolean(ConfigUtil.getString(ENABLE_JVM_STACKTRACE_PROPERTY, "false")));
+
+  private final boolean jvmStacktraceEnabled;
 
-  private DefaultExceptionAttributeResolver() {}
+  // Visible for testing
+  DefaultExceptionAttributeResolver(boolean jvmStacktraceEnabled) {
+    this.jvmStacktraceEnabled = jvmStacktraceEnabled;
+  }
 
   public static ExceptionAttributeResolver getInstance() {
     return INSTANCE;
@@ -37,14 +47,23 @@ public void setExceptionAttributes(
       attributeSetter.setAttribute(ExceptionAttributeResolver.EXCEPTION_MESSAGE, exceptionMessage);
     }
 
+    String exceptionStacktrace =
+        jvmStacktraceEnabled
+            ? jvmStacktrace(throwable)
+            : limitsAwareStacktrace(throwable, maxAttributeLength);
+    attributeSetter.setAttribute(
+        ExceptionAttributeResolver.EXCEPTION_STACKTRACE, exceptionStacktrace);
+  }
+
+  private static String jvmStacktrace(Throwable throwable) {
     StringWriter stringWriter = new StringWriter();
     try (PrintWriter printWriter = new PrintWriter(stringWriter)) {
       throwable.printStackTrace(printWriter);
     }
-    String exceptionStacktrace = stringWriter.toString();
-    if (exceptionStacktrace != null) {
-      attributeSetter.setAttribute(
-          ExceptionAttributeResolver.EXCEPTION_STACKTRACE, exceptionStacktrace);
-    }
+    return stringWriter.toString();
+  }
+
+  private static String limitsAwareStacktrace(Throwable throwable, int maxAttributeLength) {
+    return new StackTraceRenderer(throwable, maxAttributeLength).render();
   }
 }

sdk/common/src/test/java/io/opentelemetry/sdk/internal/DefaultExceptionAttributeResolverTest.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.internal;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import io.opentelemetry.api.common.AttributeKey;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+import javax.annotation.Nullable;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class DefaultExceptionAttributeResolverTest {
+
+  @ParameterizedTest
+  @MethodSource("setExceptionAttributesArgs")
+  void setExceptionAttributes(
+      boolean jvmStacktraceEnabled,
+      Throwable throwable,
+      int maxAttributeLength,
+      String expectedMessage,
+      String expectedType,
+      Predicate<String> validStacktrace) {
+    DefaultExceptionAttributeResolver resolver =
+        new DefaultExceptionAttributeResolver(jvmStacktraceEnabled);
+    Map<String, Object> attributes = new HashMap<>();
+
+    resolver.setExceptionAttributes(
+        new ExceptionAttributeResolver.AttributeSetter() {
+          @Override
+          public <T> void setAttribute(AttributeKey<T> key, @Nullable T value) {
+            attributes.put(key.toString(), value);
+          }
+        },
+        throwable,
+        maxAttributeLength);
+
+    assertThat(attributes.get(ExceptionAttributeResolver.EXCEPTION_MESSAGE.getKey()))
+        .isEqualTo(expectedMessage);
+    assertThat(attributes.get(ExceptionAttributeResolver.EXCEPTION_TYPE.getKey()))
+        .isEqualTo(expectedType);
+    assertThat((String) attributes.get(ExceptionAttributeResolver.EXCEPTION_STACKTRACE.getKey()))
+        .matches(validStacktrace);
+  }
+
+  private static Stream<Arguments> setExceptionAttributesArgs() {
+    return Stream.of(
+        // When jvmStacktraceEnabled=true, limit is ignored
+        Arguments.of(
+            true,
+            new Exception("error"),
+            10,
+            "error",
+            "java.lang.Exception",
+            predicate(stacktrace -> stacktrace.length() > 10)),
+        // When jvmStacktraceEnabled=false, limit is adhered
+        Arguments.of(
+            false,
+            new Exception("error"),
+            10,
+            "error",
+            "java.lang.Exception",
+            predicate(stacktrace -> stacktrace.length() == 10)));
+  }
+
+  private static Predicate<String> predicate(Predicate<String> predicate) {
+    return predicate;
+  }
+}