From 0637886d507c1bb61830a6348685e294bedfcda6 Mon Sep 17 00:00:00 2001 From: Trask Stalnaker Date: Thu, 29 May 2025 11:18:06 -0700 Subject: [PATCH 1/2] testing --- .../stacktrace/StackTraceAutoConfig.java | 154 +++++++++--------- 1 file changed, 78 insertions(+), 76 deletions(-) diff --git a/span-stacktrace/src/main/java/io/opentelemetry/contrib/stacktrace/StackTraceAutoConfig.java b/span-stacktrace/src/main/java/io/opentelemetry/contrib/stacktrace/StackTraceAutoConfig.java index 2315d2a10..408b3e1b9 100644 --- a/span-stacktrace/src/main/java/io/opentelemetry/contrib/stacktrace/StackTraceAutoConfig.java +++ b/span-stacktrace/src/main/java/io/opentelemetry/contrib/stacktrace/StackTraceAutoConfig.java @@ -10,102 +10,104 @@ import io.opentelemetry.sdk.autoconfigure.spi.AutoConfigurationCustomizerProvider; import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties; import io.opentelemetry.sdk.trace.ReadableSpan; + +import javax.annotation.Nullable; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import java.time.Duration; import java.util.function.Predicate; import java.util.logging.Level; import java.util.logging.Logger; -import javax.annotation.Nullable; @AutoService(AutoConfigurationCustomizerProvider.class) public class StackTraceAutoConfig implements AutoConfigurationCustomizerProvider { - private static final Logger log = Logger.getLogger(StackTraceAutoConfig.class.getName()); + private static final Logger log = + Logger.getLogger(StackTraceAutoConfig.class.getName()); - private static final String CONFIG_MIN_DURATION = - "otel.java.experimental.span-stacktrace.min.duration"; - private static final Duration CONFIG_MIN_DURATION_DEFAULT = Duration.ofMillis(5); + private static final String CONFIG_MIN_DURATION = + "otel.java.experimental.span-stacktrace.min.duration"; + private static final Duration CONFIG_MIN_DURATION_DEFAULT = Duration.ofMillis(5); - private static final String CONFIG_FILTER = "otel.java.experimental.span-stacktrace.filter"; + private static final String CONFIG_FILTER = "otel.java.experimental.span-stacktrace.filter"; - @Override - public void customize(AutoConfigurationCustomizer config) { - config.addTracerProviderCustomizer( - (providerBuilder, properties) -> { - long minDuration = getMinDuration(properties); - if (minDuration >= 0) { - Predicate filter = getFilterPredicate(properties); - providerBuilder.addSpanProcessor(new StackTraceSpanProcessor(minDuration, filter)); - } - return providerBuilder; - }); - } - - // package-private for testing - static long getMinDuration(ConfigProperties properties) { - long minDuration = - properties.getDuration(CONFIG_MIN_DURATION, CONFIG_MIN_DURATION_DEFAULT).toNanos(); - if (minDuration < 0) { - log.fine("Stack traces capture is disabled"); - } else { - log.log( - Level.FINE, - "Stack traces will be added to spans with a minimum duration of {0} nanos", - minDuration); + @Override + public void customize(AutoConfigurationCustomizer config) { + config.addTracerProviderCustomizer( + (providerBuilder, properties) -> { + long minDuration = getMinDuration(properties); + if (minDuration >= 0) { + Predicate filter = getFilterPredicate(properties); + providerBuilder.addSpanProcessor(new StackTraceSpanProcessor(minDuration, filter)); + } + return providerBuilder; + }); } - return minDuration; - } - // package private for testing - static Predicate getFilterPredicate(ConfigProperties properties) { - String filterClass = properties.getString(CONFIG_FILTER); - Predicate filter = null; - if (filterClass != null) { - Class filterType = getFilterType(filterClass); - if (filterType != null) { - filter = getFilterInstance(filterType); - } + // package-private for testing + static long getMinDuration(ConfigProperties properties) { + long minDuration = + properties.getDuration(CONFIG_MIN_DURATION, CONFIG_MIN_DURATION_DEFAULT).toNanos(); + if (minDuration < 0) { + log.fine("Stack traces capture is disabled"); + } else { + log.log( + Level.FINE, + "Stack traces will be added to spans with a minimum duration of {0} nanos", + minDuration); + } + return minDuration; } - if (filter == null) { - // if value is set, lack of filtering is likely an error and must be reported - Level disabledLogLevel = filterClass != null ? Level.SEVERE : Level.FINE; - log.log(disabledLogLevel, "Span stacktrace filtering disabled"); - return span -> true; - } else { - log.fine("Span stacktrace filtering enabled with: " + filterClass); - return filter; + // package private for testing + static Predicate getFilterPredicate(ConfigProperties properties) { + String filterClass = properties.getString(CONFIG_FILTER); + Predicate filter = null; + if (filterClass != null) { + Class filterType = getFilterType(filterClass); + if (filterType != null) { + filter = getFilterInstance(filterType); + } + } + + if (filter == null) { + // if value is set, lack of filtering is likely an error and must be reported + Level disabledLogLevel = filterClass != null ? Level.SEVERE : Level.FINE; + log.log(disabledLogLevel, "Span stacktrace filtering disabled"); + return span -> true; + } else { + log.fine("Span stacktrace filtering enabled with: " + filterClass); + return filter; + } } - } - @Nullable - private static Class getFilterType(String filterClass) { - try { - Class filterType = Class.forName(filterClass); - if (!Predicate.class.isAssignableFrom(filterType)) { - log.severe("Filter must be a subclass of java.util.function.Predicate"); - return null; - } - return filterType; - } catch (ClassNotFoundException e) { - log.severe("Unable to load filter class: " + filterClass); - return null; + @Nullable + private static Class getFilterType(String filterClass) { + try { + Class filterType = Class.forName(filterClass); + if (!Predicate.class.isAssignableFrom(filterType)) { + log.severe("Filter must be a subclass of java.util.function.Predicate"); + return null; + } + return filterType; + } catch (ClassNotFoundException e) { + log.severe("Unable to load filter class: " + filterClass); + return null; + } } - } - @Nullable - @SuppressWarnings("unchecked") - private static Predicate getFilterInstance(Class filterType) { - try { - Constructor constructor = filterType.getConstructor(); - return (Predicate) constructor.newInstance(); - } catch (NoSuchMethodException - | InstantiationException - | IllegalAccessException - | InvocationTargetException e) { - log.severe("Unable to create filter instance with no-arg constructor: " + filterType); - return null; + @Nullable + @SuppressWarnings("unchecked") + private static Predicate getFilterInstance(Class filterType) { + try { + Constructor constructor = filterType.getConstructor(); + return (Predicate) constructor.newInstance(); + } catch (NoSuchMethodException + | InstantiationException + | IllegalAccessException + | InvocationTargetException e) { + log.severe("Unable to create filter instance with no-arg constructor: " + filterType); + return null; + } } - } } From 1357d1951fa47be11128795465e801f2b8d4e325 Mon Sep 17 00:00:00 2001 From: otelbot <197425009+otelbot@users.noreply.github.com> Date: Thu, 29 May 2025 18:21:06 +0000 Subject: [PATCH 2/2] ./gradlew spotlessApply --- .../stacktrace/StackTraceAutoConfig.java | 154 +++++++++--------- 1 file changed, 76 insertions(+), 78 deletions(-) diff --git a/span-stacktrace/src/main/java/io/opentelemetry/contrib/stacktrace/StackTraceAutoConfig.java b/span-stacktrace/src/main/java/io/opentelemetry/contrib/stacktrace/StackTraceAutoConfig.java index 408b3e1b9..2315d2a10 100644 --- a/span-stacktrace/src/main/java/io/opentelemetry/contrib/stacktrace/StackTraceAutoConfig.java +++ b/span-stacktrace/src/main/java/io/opentelemetry/contrib/stacktrace/StackTraceAutoConfig.java @@ -10,104 +10,102 @@ import io.opentelemetry.sdk.autoconfigure.spi.AutoConfigurationCustomizerProvider; import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties; import io.opentelemetry.sdk.trace.ReadableSpan; - -import javax.annotation.Nullable; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import java.time.Duration; import java.util.function.Predicate; import java.util.logging.Level; import java.util.logging.Logger; +import javax.annotation.Nullable; @AutoService(AutoConfigurationCustomizerProvider.class) public class StackTraceAutoConfig implements AutoConfigurationCustomizerProvider { - private static final Logger log = - Logger.getLogger(StackTraceAutoConfig.class.getName()); + private static final Logger log = Logger.getLogger(StackTraceAutoConfig.class.getName()); - private static final String CONFIG_MIN_DURATION = - "otel.java.experimental.span-stacktrace.min.duration"; - private static final Duration CONFIG_MIN_DURATION_DEFAULT = Duration.ofMillis(5); + private static final String CONFIG_MIN_DURATION = + "otel.java.experimental.span-stacktrace.min.duration"; + private static final Duration CONFIG_MIN_DURATION_DEFAULT = Duration.ofMillis(5); - private static final String CONFIG_FILTER = "otel.java.experimental.span-stacktrace.filter"; + private static final String CONFIG_FILTER = "otel.java.experimental.span-stacktrace.filter"; - @Override - public void customize(AutoConfigurationCustomizer config) { - config.addTracerProviderCustomizer( - (providerBuilder, properties) -> { - long minDuration = getMinDuration(properties); - if (minDuration >= 0) { - Predicate filter = getFilterPredicate(properties); - providerBuilder.addSpanProcessor(new StackTraceSpanProcessor(minDuration, filter)); - } - return providerBuilder; - }); - } + @Override + public void customize(AutoConfigurationCustomizer config) { + config.addTracerProviderCustomizer( + (providerBuilder, properties) -> { + long minDuration = getMinDuration(properties); + if (minDuration >= 0) { + Predicate filter = getFilterPredicate(properties); + providerBuilder.addSpanProcessor(new StackTraceSpanProcessor(minDuration, filter)); + } + return providerBuilder; + }); + } - // package-private for testing - static long getMinDuration(ConfigProperties properties) { - long minDuration = - properties.getDuration(CONFIG_MIN_DURATION, CONFIG_MIN_DURATION_DEFAULT).toNanos(); - if (minDuration < 0) { - log.fine("Stack traces capture is disabled"); - } else { - log.log( - Level.FINE, - "Stack traces will be added to spans with a minimum duration of {0} nanos", - minDuration); - } - return minDuration; + // package-private for testing + static long getMinDuration(ConfigProperties properties) { + long minDuration = + properties.getDuration(CONFIG_MIN_DURATION, CONFIG_MIN_DURATION_DEFAULT).toNanos(); + if (minDuration < 0) { + log.fine("Stack traces capture is disabled"); + } else { + log.log( + Level.FINE, + "Stack traces will be added to spans with a minimum duration of {0} nanos", + minDuration); } + return minDuration; + } - // package private for testing - static Predicate getFilterPredicate(ConfigProperties properties) { - String filterClass = properties.getString(CONFIG_FILTER); - Predicate filter = null; - if (filterClass != null) { - Class filterType = getFilterType(filterClass); - if (filterType != null) { - filter = getFilterInstance(filterType); - } - } + // package private for testing + static Predicate getFilterPredicate(ConfigProperties properties) { + String filterClass = properties.getString(CONFIG_FILTER); + Predicate filter = null; + if (filterClass != null) { + Class filterType = getFilterType(filterClass); + if (filterType != null) { + filter = getFilterInstance(filterType); + } + } - if (filter == null) { - // if value is set, lack of filtering is likely an error and must be reported - Level disabledLogLevel = filterClass != null ? Level.SEVERE : Level.FINE; - log.log(disabledLogLevel, "Span stacktrace filtering disabled"); - return span -> true; - } else { - log.fine("Span stacktrace filtering enabled with: " + filterClass); - return filter; - } + if (filter == null) { + // if value is set, lack of filtering is likely an error and must be reported + Level disabledLogLevel = filterClass != null ? Level.SEVERE : Level.FINE; + log.log(disabledLogLevel, "Span stacktrace filtering disabled"); + return span -> true; + } else { + log.fine("Span stacktrace filtering enabled with: " + filterClass); + return filter; } + } - @Nullable - private static Class getFilterType(String filterClass) { - try { - Class filterType = Class.forName(filterClass); - if (!Predicate.class.isAssignableFrom(filterType)) { - log.severe("Filter must be a subclass of java.util.function.Predicate"); - return null; - } - return filterType; - } catch (ClassNotFoundException e) { - log.severe("Unable to load filter class: " + filterClass); - return null; - } + @Nullable + private static Class getFilterType(String filterClass) { + try { + Class filterType = Class.forName(filterClass); + if (!Predicate.class.isAssignableFrom(filterType)) { + log.severe("Filter must be a subclass of java.util.function.Predicate"); + return null; + } + return filterType; + } catch (ClassNotFoundException e) { + log.severe("Unable to load filter class: " + filterClass); + return null; } + } - @Nullable - @SuppressWarnings("unchecked") - private static Predicate getFilterInstance(Class filterType) { - try { - Constructor constructor = filterType.getConstructor(); - return (Predicate) constructor.newInstance(); - } catch (NoSuchMethodException - | InstantiationException - | IllegalAccessException - | InvocationTargetException e) { - log.severe("Unable to create filter instance with no-arg constructor: " + filterType); - return null; - } + @Nullable + @SuppressWarnings("unchecked") + private static Predicate getFilterInstance(Class filterType) { + try { + Constructor constructor = filterType.getConstructor(); + return (Predicate) constructor.newInstance(); + } catch (NoSuchMethodException + | InstantiationException + | IllegalAccessException + | InvocationTargetException e) { + log.severe("Unable to create filter instance with no-arg constructor: " + filterType); + return null; } + } }