From e799392e90367ec0d93b37911b10998ab549b872 Mon Sep 17 00:00:00 2001 From: Rupinder Singh Date: Tue, 13 Jun 2023 11:00:20 -0400 Subject: [PATCH 1/4] Added OpenTelemetry field to the OpenTelemetryAppender --- .../appender/v2_17/OpenTelemetryAppender.java | 28 +- .../OpenTelemetryAppenderConfigTest.java | 1 - ...ryAppenderConfigWithOpenTelemetryTest.java | 254 ++++++++++++++++++ 3 files changed, 279 insertions(+), 4 deletions(-) create mode 100644 instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigWithOpenTelemetryTest.java diff --git a/instrumentation/log4j/log4j-appender-2.17/library/src/main/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppender.java b/instrumentation/log4j/log4j-appender-2.17/library/src/main/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppender.java index da324cb6aa52..475650ed044b 100644 --- a/instrumentation/log4j/log4j-appender-2.17/library/src/main/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppender.java +++ b/instrumentation/log4j/log4j-appender-2.17/library/src/main/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppender.java @@ -9,6 +9,7 @@ import com.google.errorprone.annotations.CanIgnoreReturnValue; import io.opentelemetry.api.GlobalOpenTelemetry; +import io.opentelemetry.api.OpenTelemetry; import io.opentelemetry.api.logs.LogRecordBuilder; import io.opentelemetry.instrumentation.log4j.appender.v2_17.internal.ContextDataAccessor; import io.opentelemetry.instrumentation.log4j.appender.v2_17.internal.LogEventMapper; @@ -43,6 +44,7 @@ public class OpenTelemetryAppender extends AbstractAppender { static final String PLUGIN_NAME = "OpenTelemetry"; private final LogEventMapper mapper; + private OpenTelemetry openTelemetry; @PluginBuilderFactory public static > B builder() { @@ -57,6 +59,8 @@ public static class Builder> extends AbstractAppender.Build @PluginBuilderAttribute private boolean captureMarkerAttribute; @PluginBuilderAttribute private String captureContextDataAttributes; + private OpenTelemetry openTelemetry; + /** * Sets whether experimental attributes should be set to logs. These attributes may be changed * or removed in the future, so only enable this if you know you do not require attributes @@ -93,6 +97,12 @@ public B setCaptureContextDataAttributes(String captureContextDataAttributes) { return asBuilder(); } + @CanIgnoreReturnValue + public B setOpenTelemtry(OpenTelemetry openTelemetry) { + this.openTelemetry = openTelemetry; + return asBuilder(); + } + @Override public OpenTelemetryAppender build() { return new OpenTelemetryAppender( @@ -104,7 +114,8 @@ public OpenTelemetryAppender build() { captureExperimentalAttributes, captureMapMessageAttributes, captureMarkerAttribute, - captureContextDataAttributes); + captureContextDataAttributes, + openTelemetry); } } @@ -117,7 +128,8 @@ private OpenTelemetryAppender( boolean captureExperimentalAttributes, boolean captureMapMessageAttributes, boolean captureMarkerAttribute, - String captureContextDataAttributes) { + String captureContextDataAttributes, + OpenTelemetry openTelemetry) { super(name, filter, layout, ignoreExceptions, properties); this.mapper = @@ -127,6 +139,7 @@ private OpenTelemetryAppender( captureMapMessageAttributes, captureMarkerAttribute, splitAndFilterBlanksAndNulls(captureContextDataAttributes)); + this.openTelemetry = openTelemetry; } private static List splitAndFilterBlanksAndNulls(String value) { @@ -139,14 +152,23 @@ private static List splitAndFilterBlanksAndNulls(String value) { .collect(Collectors.toList()); } + public void setOpenTelemetry(OpenTelemetry openTelemetry) { + this.openTelemetry = openTelemetry; + } + + public OpenTelemetry getOpenTelemetry() { + return openTelemetry == null ? GlobalOpenTelemetry.get() : openTelemetry; + } + @Override public void append(LogEvent event) { String instrumentationName = event.getLoggerName(); if (instrumentationName == null || instrumentationName.isEmpty()) { instrumentationName = "ROOT"; } + LogRecordBuilder builder = - GlobalOpenTelemetry.get() + getOpenTelemetry() .getLogsBridge() .loggerBuilder(instrumentationName) .build() diff --git a/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigTest.java b/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigTest.java index 243fa02efec9..5d858104108e 100644 --- a/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigTest.java +++ b/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigTest.java @@ -61,7 +61,6 @@ static void setupAll() { .addLogRecordProcessor(SimpleLogRecordProcessor.create(logRecordExporter)) .build(); - GlobalOpenTelemetry.resetForTest(); GlobalOpenTelemetry.set(OpenTelemetrySdk.builder().setLoggerProvider(loggerProvider).build()); } diff --git a/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigWithOpenTelemetryTest.java b/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigWithOpenTelemetryTest.java new file mode 100644 index 000000000000..58c4d3284196 --- /dev/null +++ b/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigWithOpenTelemetryTest.java @@ -0,0 +1,254 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.log4j.appender.v2_17; + +import static io.opentelemetry.api.common.AttributeKey.stringKey; +import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat; +import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo; +import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.satisfies; + +import io.opentelemetry.api.OpenTelemetry; +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.logs.Severity; +import io.opentelemetry.api.trace.Span; +import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.context.Scope; +import io.opentelemetry.sdk.OpenTelemetrySdk; +import io.opentelemetry.sdk.common.InstrumentationScopeInfo; +import io.opentelemetry.sdk.logs.SdkLoggerProvider; +import io.opentelemetry.sdk.logs.data.LogRecordData; +import io.opentelemetry.sdk.logs.export.SimpleLogRecordProcessor; +import io.opentelemetry.sdk.resources.Resource; +import io.opentelemetry.sdk.testing.exporter.InMemoryLogRecordExporter; +import io.opentelemetry.sdk.trace.SdkTracerProvider; +import io.opentelemetry.semconv.trace.attributes.SemanticAttributes; +import java.time.Instant; +import java.util.List; +import java.util.concurrent.TimeUnit; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.apache.logging.log4j.Marker; +import org.apache.logging.log4j.MarkerManager; +import org.apache.logging.log4j.ThreadContext; +import org.apache.logging.log4j.core.LoggerContext; +import org.apache.logging.log4j.core.config.Configuration; +import org.apache.logging.log4j.core.impl.Log4jLogEvent; +import org.apache.logging.log4j.message.FormattedMessage; +import org.apache.logging.log4j.message.StringMapMessage; +import org.apache.logging.log4j.message.StructuredDataMessage; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class OpenTelemetryAppenderConfigWithOpenTelemetryTest { + + private static final Logger logger = LogManager.getLogger("TestLogger"); + + private static InMemoryLogRecordExporter logRecordExporter; + private static Resource resource; + private static InstrumentationScopeInfo instrumentationScopeInfo; + private static OpenTelemetry openTelemetry; + + @BeforeAll + static void setupAll() { + logRecordExporter = InMemoryLogRecordExporter.create(); + resource = Resource.getDefault(); + instrumentationScopeInfo = InstrumentationScopeInfo.create("TestLogger"); + + SdkLoggerProvider loggerProvider = + SdkLoggerProvider.builder() + .setResource(resource) + .addLogRecordProcessor(SimpleLogRecordProcessor.create(logRecordExporter)) + .build(); + + openTelemetry = OpenTelemetrySdk.builder().setLoggerProvider(loggerProvider).build(); + setOpenTelemetry(openTelemetry); + } + + private static void setOpenTelemetry(OpenTelemetry openTelemetry) { + Configuration config = ((LoggerContext) LogManager.getContext(false)).getConfiguration(); + config.getAppenders().values().stream() + .filter(a -> a instanceof OpenTelemetryAppender) + .forEach(a -> ((OpenTelemetryAppender) a).setOpenTelemetry(openTelemetry)); + } + + @AfterAll + static void cleanupAll() { + // This is to make sure that other test classes don't have issues with the logger provider set + setOpenTelemetry(null); + } + + @BeforeEach + void setup() { + logRecordExporter.reset(); + ThreadContext.clearAll(); + } + + @Test + void initializeWithBuilder() { + OpenTelemetryAppender appender = + OpenTelemetryAppender.builder() + .setName("OpenTelemetryAppender") + .setOpenTelemtry(openTelemetry) + .build(); + appender.start(); + + appender.append( + Log4jLogEvent.newBuilder() + .setMessage(new FormattedMessage("log message 1", (Object) null)) + .build()); + + List logDataList = logRecordExporter.getFinishedLogRecordItems(); + assertThat(logDataList) + .satisfiesExactly(logRecordData -> assertThat(logDataList.get(0)).hasBody("log message 1")); + } + + @Test + void logNoSpan() { + logger.info("log message 1"); + + List logDataList = logRecordExporter.getFinishedLogRecordItems(); + assertThat(logDataList).hasSize(1); + assertThat(logDataList.get(0)) + .hasResource(resource) + .hasInstrumentationScope(instrumentationScopeInfo) + .hasBody("log message 1") + .hasAttributes(Attributes.empty()); + } + + @Test + void logWithSpan() { + Span span1 = runWithSpan("span1", () -> logger.info("log message 1")); + + logger.info("log message 2"); + + Span span2 = runWithSpan("span2", () -> logger.info("log message 3")); + + List logDataList = logRecordExporter.getFinishedLogRecordItems(); + assertThat(logDataList).hasSize(3); + assertThat(logDataList.get(0).getSpanContext()).isEqualTo(span1.getSpanContext()); + assertThat(logDataList.get(1).getSpanContext()).isEqualTo(SpanContext.getInvalid()); + assertThat(logDataList.get(2).getSpanContext()).isEqualTo(span2.getSpanContext()); + } + + private static Span runWithSpan(String spanName, Runnable runnable) { + Span span = SdkTracerProvider.builder().build().get("tracer").spanBuilder(spanName).startSpan(); + try (Scope ignored = span.makeCurrent()) { + runnable.run(); + } finally { + span.end(); + } + return span; + } + + @Test + void logWithExtras() { + Instant start = Instant.now(); + logger.info("log message 1", new IllegalStateException("Error!")); + + List logDataList = logRecordExporter.getFinishedLogRecordItems(); + assertThat(logDataList).hasSize(1); + assertThat(logDataList.get(0)) + .hasResource(resource) + .hasInstrumentationScope(instrumentationScopeInfo) + .hasBody("log message 1") + .hasSeverity(Severity.INFO) + .hasSeverityText("INFO") + .hasAttributesSatisfyingExactly( + equalTo(SemanticAttributes.EXCEPTION_TYPE, IllegalStateException.class.getName()), + equalTo(SemanticAttributes.EXCEPTION_MESSAGE, "Error!"), + satisfies(SemanticAttributes.EXCEPTION_STACKTRACE, v -> v.contains("logWithExtras"))); + + assertThat(logDataList.get(0).getTimestampEpochNanos()) + .isGreaterThanOrEqualTo(TimeUnit.MILLISECONDS.toNanos(start.toEpochMilli())) + .isLessThanOrEqualTo(TimeUnit.MILLISECONDS.toNanos(Instant.now().toEpochMilli())); + } + + @Test + void logContextData() { + ThreadContext.put("key1", "val1"); + ThreadContext.put("key2", "val2"); + try { + logger.info("log message 1"); + } finally { + ThreadContext.clearMap(); + } + + List logDataList = logRecordExporter.getFinishedLogRecordItems(); + assertThat(logDataList).hasSize(1); + assertThat(logDataList.get(0)) + .hasResource(resource) + .hasInstrumentationScope(instrumentationScopeInfo) + .hasBody("log message 1") + .hasAttributesSatisfyingExactly( + equalTo(stringKey("log4j.context_data.key1"), "val1"), + equalTo(stringKey("log4j.context_data.key2"), "val2")); + } + + @Test + void logStringMapMessage() { + StringMapMessage message = new StringMapMessage(); + message.put("key1", "val1"); + message.put("key2", "val2"); + logger.info(message); + + List logDataList = logRecordExporter.getFinishedLogRecordItems(); + assertThat(logDataList).hasSize(1); + assertThat(logDataList.get(0)) + .hasResource(resource) + .hasInstrumentationScope(instrumentationScopeInfo) + .hasAttributesSatisfyingExactly( + equalTo(stringKey("log4j.map_message.key1"), "val1"), + equalTo(stringKey("log4j.map_message.key2"), "val2")); + } + + @Test + void logStringMapMessageWithSpecialAttribute() { + StringMapMessage message = new StringMapMessage(); + message.put("key1", "val1"); + message.put("message", "val2"); + logger.info(message); + + List logDataList = logRecordExporter.getFinishedLogRecordItems(); + assertThat(logDataList).hasSize(1); + assertThat(logDataList.get(0)) + .hasResource(resource) + .hasInstrumentationScope(instrumentationScopeInfo) + .hasBody("val2") + .hasAttributesSatisfyingExactly(equalTo(stringKey("log4j.map_message.key1"), "val1")); + } + + @Test + void testCaptureMarkerAttribute() { + String markerName = "aMarker"; + Marker marker = MarkerManager.getMarker(markerName); + + logger.info(marker, "Message"); + + List logDataList = logRecordExporter.getFinishedLogRecordItems(); + LogRecordData logData = logDataList.get(0); + assertThat(logData.getAttributes().get(stringKey("log4j.marker"))).isEqualTo(markerName); + } + + @Test + void logStructuredDataMessage() { + StructuredDataMessage message = new StructuredDataMessage("an id", "a message", "a type"); + message.put("key1", "val1"); + message.put("key2", "val2"); + logger.info(message); + + List logDataList = logRecordExporter.getFinishedLogRecordItems(); + assertThat(logDataList).hasSize(1); + assertThat(logDataList.get(0)) + .hasResource(resource) + .hasInstrumentationScope(instrumentationScopeInfo) + .hasBody("a message") + .hasAttributesSatisfyingExactly( + equalTo(stringKey("log4j.map_message.key1"), "val1"), + equalTo(stringKey("log4j.map_message.key2"), "val2")); + } +} From 964d8c68215627b2df681fd7b4e3026d71a88220 Mon Sep 17 00:00:00 2001 From: Rupinder Singh Date: Wed, 14 Jun 2023 09:40:35 -0400 Subject: [PATCH 2/4] Refactored tests to create common abstract class and made OpenTelemetry field private in the appender --- .../appender/v2_17/OpenTelemetryAppender.java | 6 +- .../OpenTelemetryAppenderConfigTest.java | 180 +--------------- .../OpenTelemetryAppenderConfigTestBase.java | 197 ++++++++++++++++++ ...ryAppenderConfigWithOpenTelemetryTest.java | 180 +--------------- 4 files changed, 203 insertions(+), 360 deletions(-) create mode 100644 instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigTestBase.java diff --git a/instrumentation/log4j/log4j-appender-2.17/library/src/main/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppender.java b/instrumentation/log4j/log4j-appender-2.17/library/src/main/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppender.java index 475650ed044b..aa7e656c2e4a 100644 --- a/instrumentation/log4j/log4j-appender-2.17/library/src/main/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppender.java +++ b/instrumentation/log4j/log4j-appender-2.17/library/src/main/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppender.java @@ -44,7 +44,7 @@ public class OpenTelemetryAppender extends AbstractAppender { static final String PLUGIN_NAME = "OpenTelemetry"; private final LogEventMapper mapper; - private OpenTelemetry openTelemetry; + @Nullable private OpenTelemetry openTelemetry; @PluginBuilderFactory public static > B builder() { @@ -59,7 +59,7 @@ public static class Builder> extends AbstractAppender.Build @PluginBuilderAttribute private boolean captureMarkerAttribute; @PluginBuilderAttribute private String captureContextDataAttributes; - private OpenTelemetry openTelemetry; + @Nullable private OpenTelemetry openTelemetry; /** * Sets whether experimental attributes should be set to logs. These attributes may be changed @@ -156,7 +156,7 @@ public void setOpenTelemetry(OpenTelemetry openTelemetry) { this.openTelemetry = openTelemetry; } - public OpenTelemetry getOpenTelemetry() { + private OpenTelemetry getOpenTelemetry() { return openTelemetry == null ? GlobalOpenTelemetry.get() : openTelemetry; } diff --git a/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigTest.java b/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigTest.java index 5d858104108e..f442c807fb41 100644 --- a/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigTest.java +++ b/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigTest.java @@ -5,17 +5,9 @@ package io.opentelemetry.instrumentation.log4j.appender.v2_17; -import static io.opentelemetry.api.common.AttributeKey.stringKey; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat; -import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo; -import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.satisfies; import io.opentelemetry.api.GlobalOpenTelemetry; -import io.opentelemetry.api.common.Attributes; -import io.opentelemetry.api.logs.Severity; -import io.opentelemetry.api.trace.Span; -import io.opentelemetry.api.trace.SpanContext; -import io.opentelemetry.context.Scope; import io.opentelemetry.sdk.OpenTelemetrySdk; import io.opentelemetry.sdk.common.InstrumentationScopeInfo; import io.opentelemetry.sdk.logs.SdkLoggerProvider; @@ -23,31 +15,13 @@ import io.opentelemetry.sdk.logs.export.SimpleLogRecordProcessor; import io.opentelemetry.sdk.resources.Resource; import io.opentelemetry.sdk.testing.exporter.InMemoryLogRecordExporter; -import io.opentelemetry.sdk.trace.SdkTracerProvider; -import io.opentelemetry.semconv.trace.attributes.SemanticAttributes; -import java.time.Instant; import java.util.List; -import java.util.concurrent.TimeUnit; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; -import org.apache.logging.log4j.Marker; -import org.apache.logging.log4j.MarkerManager; -import org.apache.logging.log4j.ThreadContext; import org.apache.logging.log4j.core.impl.Log4jLogEvent; import org.apache.logging.log4j.message.FormattedMessage; -import org.apache.logging.log4j.message.StringMapMessage; -import org.apache.logging.log4j.message.StructuredDataMessage; import org.junit.jupiter.api.BeforeAll; -import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -class OpenTelemetryAppenderConfigTest { - - private static final Logger logger = LogManager.getLogger("TestLogger"); - - private static InMemoryLogRecordExporter logRecordExporter; - private static Resource resource; - private static InstrumentationScopeInfo instrumentationScopeInfo; +class OpenTelemetryAppenderConfigTest extends OpenTelemetryAppenderConfigTestBase { @BeforeAll static void setupAll() { @@ -61,15 +35,10 @@ static void setupAll() { .addLogRecordProcessor(SimpleLogRecordProcessor.create(logRecordExporter)) .build(); + GlobalOpenTelemetry.resetForTest(); GlobalOpenTelemetry.set(OpenTelemetrySdk.builder().setLoggerProvider(loggerProvider).build()); } - @BeforeEach - void setup() { - logRecordExporter.reset(); - ThreadContext.clearAll(); - } - @Test void initializeWithBuilder() { OpenTelemetryAppender appender = @@ -85,149 +54,4 @@ void initializeWithBuilder() { assertThat(logDataList) .satisfiesExactly(logRecordData -> assertThat(logDataList.get(0)).hasBody("log message 1")); } - - @Test - void logNoSpan() { - logger.info("log message 1"); - - List logDataList = logRecordExporter.getFinishedLogRecordItems(); - assertThat(logDataList).hasSize(1); - assertThat(logDataList.get(0)) - .hasResource(resource) - .hasInstrumentationScope(instrumentationScopeInfo) - .hasBody("log message 1") - .hasAttributes(Attributes.empty()); - } - - @Test - void logWithSpan() { - Span span1 = runWithSpan("span1", () -> logger.info("log message 1")); - - logger.info("log message 2"); - - Span span2 = runWithSpan("span2", () -> logger.info("log message 3")); - - List logDataList = logRecordExporter.getFinishedLogRecordItems(); - assertThat(logDataList).hasSize(3); - assertThat(logDataList.get(0).getSpanContext()).isEqualTo(span1.getSpanContext()); - assertThat(logDataList.get(1).getSpanContext()).isEqualTo(SpanContext.getInvalid()); - assertThat(logDataList.get(2).getSpanContext()).isEqualTo(span2.getSpanContext()); - } - - private static Span runWithSpan(String spanName, Runnable runnable) { - Span span = SdkTracerProvider.builder().build().get("tracer").spanBuilder(spanName).startSpan(); - try (Scope ignored = span.makeCurrent()) { - runnable.run(); - } finally { - span.end(); - } - return span; - } - - @Test - void logWithExtras() { - Instant start = Instant.now(); - logger.info("log message 1", new IllegalStateException("Error!")); - - List logDataList = logRecordExporter.getFinishedLogRecordItems(); - assertThat(logDataList).hasSize(1); - assertThat(logDataList.get(0)) - .hasResource(resource) - .hasInstrumentationScope(instrumentationScopeInfo) - .hasBody("log message 1") - .hasSeverity(Severity.INFO) - .hasSeverityText("INFO") - .hasAttributesSatisfyingExactly( - equalTo(SemanticAttributes.EXCEPTION_TYPE, IllegalStateException.class.getName()), - equalTo(SemanticAttributes.EXCEPTION_MESSAGE, "Error!"), - satisfies(SemanticAttributes.EXCEPTION_STACKTRACE, v -> v.contains("logWithExtras"))); - - assertThat(logDataList.get(0).getTimestampEpochNanos()) - .isGreaterThanOrEqualTo(TimeUnit.MILLISECONDS.toNanos(start.toEpochMilli())) - .isLessThanOrEqualTo(TimeUnit.MILLISECONDS.toNanos(Instant.now().toEpochMilli())); - } - - @Test - void logContextData() { - ThreadContext.put("key1", "val1"); - ThreadContext.put("key2", "val2"); - try { - logger.info("log message 1"); - } finally { - ThreadContext.clearMap(); - } - - List logDataList = logRecordExporter.getFinishedLogRecordItems(); - assertThat(logDataList).hasSize(1); - assertThat(logDataList.get(0)) - .hasResource(resource) - .hasInstrumentationScope(instrumentationScopeInfo) - .hasBody("log message 1") - .hasAttributesSatisfyingExactly( - equalTo(stringKey("log4j.context_data.key1"), "val1"), - equalTo(stringKey("log4j.context_data.key2"), "val2")); - } - - @Test - void logStringMapMessage() { - StringMapMessage message = new StringMapMessage(); - message.put("key1", "val1"); - message.put("key2", "val2"); - logger.info(message); - - List logDataList = logRecordExporter.getFinishedLogRecordItems(); - assertThat(logDataList).hasSize(1); - assertThat(logDataList.get(0)) - .hasResource(resource) - .hasInstrumentationScope(instrumentationScopeInfo) - .hasAttributesSatisfyingExactly( - equalTo(stringKey("log4j.map_message.key1"), "val1"), - equalTo(stringKey("log4j.map_message.key2"), "val2")); - } - - @Test - void logStringMapMessageWithSpecialAttribute() { - StringMapMessage message = new StringMapMessage(); - message.put("key1", "val1"); - message.put("message", "val2"); - logger.info(message); - - List logDataList = logRecordExporter.getFinishedLogRecordItems(); - assertThat(logDataList).hasSize(1); - assertThat(logDataList.get(0)) - .hasResource(resource) - .hasInstrumentationScope(instrumentationScopeInfo) - .hasBody("val2") - .hasAttributesSatisfyingExactly(equalTo(stringKey("log4j.map_message.key1"), "val1")); - } - - @Test - void testCaptureMarkerAttribute() { - String markerName = "aMarker"; - Marker marker = MarkerManager.getMarker(markerName); - - logger.info(marker, "Message"); - - List logDataList = logRecordExporter.getFinishedLogRecordItems(); - LogRecordData logData = logDataList.get(0); - assertThat(logData.getAttributes().get(stringKey("log4j.marker"))).isEqualTo(markerName); - } - - @Test - void logStructuredDataMessage() { - StructuredDataMessage message = new StructuredDataMessage("an id", "a message", "a type"); - message.put("key1", "val1"); - message.put("key2", "val2"); - logger.info(message); - - List logDataList = logRecordExporter.getFinishedLogRecordItems(); - assertThat(logDataList).hasSize(1); - assertThat(logDataList.get(0)) - .hasResource(resource) - .hasInstrumentationScope(instrumentationScopeInfo) - .hasBody("a message") - .hasAttributesSatisfyingExactly( - equalTo(stringKey("log4j.map_message.key1"), "val1"), - equalTo(stringKey("log4j.map_message.key2"), "val2")); - } } diff --git a/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigTestBase.java b/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigTestBase.java new file mode 100644 index 000000000000..f35564694fcb --- /dev/null +++ b/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigTestBase.java @@ -0,0 +1,197 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.log4j.appender.v2_17; + +import static io.opentelemetry.api.common.AttributeKey.stringKey; +import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat; +import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo; +import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.satisfies; + +import io.opentelemetry.api.OpenTelemetry; +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.logs.Severity; +import io.opentelemetry.api.trace.Span; +import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.context.Scope; +import io.opentelemetry.sdk.common.InstrumentationScopeInfo; +import io.opentelemetry.sdk.logs.data.LogRecordData; +import io.opentelemetry.sdk.resources.Resource; +import io.opentelemetry.sdk.testing.exporter.InMemoryLogRecordExporter; +import io.opentelemetry.sdk.trace.SdkTracerProvider; +import io.opentelemetry.semconv.trace.attributes.SemanticAttributes; +import java.time.Instant; +import java.util.List; +import java.util.concurrent.TimeUnit; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.apache.logging.log4j.Marker; +import org.apache.logging.log4j.MarkerManager; +import org.apache.logging.log4j.ThreadContext; +import org.apache.logging.log4j.message.StringMapMessage; +import org.apache.logging.log4j.message.StructuredDataMessage; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +abstract class OpenTelemetryAppenderConfigTestBase { + + static final Logger logger = LogManager.getLogger("TestLogger"); + + static InMemoryLogRecordExporter logRecordExporter; + static Resource resource; + static InstrumentationScopeInfo instrumentationScopeInfo; + static OpenTelemetry openTelemetry; + + @BeforeEach + void setup() { + logRecordExporter.reset(); + ThreadContext.clearAll(); + } + + @Test + void logNoSpan() { + logger.info("log message 1"); + + List logDataList = logRecordExporter.getFinishedLogRecordItems(); + assertThat(logDataList).hasSize(1); + assertThat(logDataList.get(0)) + .hasResource(resource) + .hasInstrumentationScope(instrumentationScopeInfo) + .hasBody("log message 1") + .hasAttributes(Attributes.empty()); + } + + @Test + void logWithSpan() { + Span span1 = runWithSpan("span1", () -> logger.info("log message 1")); + + logger.info("log message 2"); + + Span span2 = runWithSpan("span2", () -> logger.info("log message 3")); + + List logDataList = logRecordExporter.getFinishedLogRecordItems(); + assertThat(logDataList).hasSize(3); + assertThat(logDataList.get(0).getSpanContext()).isEqualTo(span1.getSpanContext()); + assertThat(logDataList.get(1).getSpanContext()).isEqualTo(SpanContext.getInvalid()); + assertThat(logDataList.get(2).getSpanContext()).isEqualTo(span2.getSpanContext()); + } + + private static Span runWithSpan(String spanName, Runnable runnable) { + Span span = SdkTracerProvider.builder().build().get("tracer").spanBuilder(spanName).startSpan(); + try (Scope ignored = span.makeCurrent()) { + runnable.run(); + } finally { + span.end(); + } + return span; + } + + @Test + void logWithExtras() { + Instant start = Instant.now(); + logger.info("log message 1", new IllegalStateException("Error!")); + + List logDataList = logRecordExporter.getFinishedLogRecordItems(); + assertThat(logDataList).hasSize(1); + assertThat(logDataList.get(0)) + .hasResource(resource) + .hasInstrumentationScope(instrumentationScopeInfo) + .hasBody("log message 1") + .hasSeverity(Severity.INFO) + .hasSeverityText("INFO") + .hasAttributesSatisfyingExactly( + equalTo(SemanticAttributes.EXCEPTION_TYPE, IllegalStateException.class.getName()), + equalTo(SemanticAttributes.EXCEPTION_MESSAGE, "Error!"), + satisfies(SemanticAttributes.EXCEPTION_STACKTRACE, v -> v.contains("logWithExtras"))); + + assertThat(logDataList.get(0).getTimestampEpochNanos()) + .isGreaterThanOrEqualTo(TimeUnit.MILLISECONDS.toNanos(start.toEpochMilli())) + .isLessThanOrEqualTo(TimeUnit.MILLISECONDS.toNanos(Instant.now().toEpochMilli())); + } + + @Test + void logContextData() { + ThreadContext.put("key1", "val1"); + ThreadContext.put("key2", "val2"); + try { + logger.info("log message 1"); + } finally { + ThreadContext.clearMap(); + } + + List logDataList = logRecordExporter.getFinishedLogRecordItems(); + assertThat(logDataList).hasSize(1); + assertThat(logDataList.get(0)) + .hasResource(resource) + .hasInstrumentationScope(instrumentationScopeInfo) + .hasBody("log message 1") + .hasAttributesSatisfyingExactly( + equalTo(stringKey("log4j.context_data.key1"), "val1"), + equalTo(stringKey("log4j.context_data.key2"), "val2")); + } + + @Test + void logStringMapMessage() { + StringMapMessage message = new StringMapMessage(); + message.put("key1", "val1"); + message.put("key2", "val2"); + logger.info(message); + + List logDataList = logRecordExporter.getFinishedLogRecordItems(); + assertThat(logDataList).hasSize(1); + assertThat(logDataList.get(0)) + .hasResource(resource) + .hasInstrumentationScope(instrumentationScopeInfo) + .hasAttributesSatisfyingExactly( + equalTo(stringKey("log4j.map_message.key1"), "val1"), + equalTo(stringKey("log4j.map_message.key2"), "val2")); + } + + @Test + void logStringMapMessageWithSpecialAttribute() { + StringMapMessage message = new StringMapMessage(); + message.put("key1", "val1"); + message.put("message", "val2"); + logger.info(message); + + List logDataList = logRecordExporter.getFinishedLogRecordItems(); + assertThat(logDataList).hasSize(1); + assertThat(logDataList.get(0)) + .hasResource(resource) + .hasInstrumentationScope(instrumentationScopeInfo) + .hasBody("val2") + .hasAttributesSatisfyingExactly(equalTo(stringKey("log4j.map_message.key1"), "val1")); + } + + @Test + void testCaptureMarkerAttribute() { + String markerName = "aMarker"; + Marker marker = MarkerManager.getMarker(markerName); + + logger.info(marker, "Message"); + + List logDataList = logRecordExporter.getFinishedLogRecordItems(); + LogRecordData logData = logDataList.get(0); + assertThat(logData.getAttributes().get(stringKey("log4j.marker"))).isEqualTo(markerName); + } + + @Test + void logStructuredDataMessage() { + StructuredDataMessage message = new StructuredDataMessage("an id", "a message", "a type"); + message.put("key1", "val1"); + message.put("key2", "val2"); + logger.info(message); + + List logDataList = logRecordExporter.getFinishedLogRecordItems(); + assertThat(logDataList).hasSize(1); + assertThat(logDataList.get(0)) + .hasResource(resource) + .hasInstrumentationScope(instrumentationScopeInfo) + .hasBody("a message") + .hasAttributesSatisfyingExactly( + equalTo(stringKey("log4j.map_message.key1"), "val1"), + equalTo(stringKey("log4j.map_message.key2"), "val2")); + } +} diff --git a/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigWithOpenTelemetryTest.java b/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigWithOpenTelemetryTest.java index 58c4d3284196..5e8e7d3b4c3f 100644 --- a/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigWithOpenTelemetryTest.java +++ b/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigWithOpenTelemetryTest.java @@ -5,17 +5,9 @@ package io.opentelemetry.instrumentation.log4j.appender.v2_17; -import static io.opentelemetry.api.common.AttributeKey.stringKey; import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat; -import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo; -import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.satisfies; import io.opentelemetry.api.OpenTelemetry; -import io.opentelemetry.api.common.Attributes; -import io.opentelemetry.api.logs.Severity; -import io.opentelemetry.api.trace.Span; -import io.opentelemetry.api.trace.SpanContext; -import io.opentelemetry.context.Scope; import io.opentelemetry.sdk.OpenTelemetrySdk; import io.opentelemetry.sdk.common.InstrumentationScopeInfo; import io.opentelemetry.sdk.logs.SdkLoggerProvider; @@ -23,36 +15,17 @@ import io.opentelemetry.sdk.logs.export.SimpleLogRecordProcessor; import io.opentelemetry.sdk.resources.Resource; import io.opentelemetry.sdk.testing.exporter.InMemoryLogRecordExporter; -import io.opentelemetry.sdk.trace.SdkTracerProvider; -import io.opentelemetry.semconv.trace.attributes.SemanticAttributes; -import java.time.Instant; import java.util.List; -import java.util.concurrent.TimeUnit; import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; -import org.apache.logging.log4j.Marker; -import org.apache.logging.log4j.MarkerManager; -import org.apache.logging.log4j.ThreadContext; import org.apache.logging.log4j.core.LoggerContext; import org.apache.logging.log4j.core.config.Configuration; import org.apache.logging.log4j.core.impl.Log4jLogEvent; import org.apache.logging.log4j.message.FormattedMessage; -import org.apache.logging.log4j.message.StringMapMessage; -import org.apache.logging.log4j.message.StructuredDataMessage; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; -import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -class OpenTelemetryAppenderConfigWithOpenTelemetryTest { - - private static final Logger logger = LogManager.getLogger("TestLogger"); - - private static InMemoryLogRecordExporter logRecordExporter; - private static Resource resource; - private static InstrumentationScopeInfo instrumentationScopeInfo; - private static OpenTelemetry openTelemetry; - +class OpenTelemetryAppenderConfigWithOpenTelemetryTest extends OpenTelemetryAppenderConfigTestBase { @BeforeAll static void setupAll() { logRecordExporter = InMemoryLogRecordExporter.create(); @@ -82,12 +55,6 @@ static void cleanupAll() { setOpenTelemetry(null); } - @BeforeEach - void setup() { - logRecordExporter.reset(); - ThreadContext.clearAll(); - } - @Test void initializeWithBuilder() { OpenTelemetryAppender appender = @@ -106,149 +73,4 @@ void initializeWithBuilder() { assertThat(logDataList) .satisfiesExactly(logRecordData -> assertThat(logDataList.get(0)).hasBody("log message 1")); } - - @Test - void logNoSpan() { - logger.info("log message 1"); - - List logDataList = logRecordExporter.getFinishedLogRecordItems(); - assertThat(logDataList).hasSize(1); - assertThat(logDataList.get(0)) - .hasResource(resource) - .hasInstrumentationScope(instrumentationScopeInfo) - .hasBody("log message 1") - .hasAttributes(Attributes.empty()); - } - - @Test - void logWithSpan() { - Span span1 = runWithSpan("span1", () -> logger.info("log message 1")); - - logger.info("log message 2"); - - Span span2 = runWithSpan("span2", () -> logger.info("log message 3")); - - List logDataList = logRecordExporter.getFinishedLogRecordItems(); - assertThat(logDataList).hasSize(3); - assertThat(logDataList.get(0).getSpanContext()).isEqualTo(span1.getSpanContext()); - assertThat(logDataList.get(1).getSpanContext()).isEqualTo(SpanContext.getInvalid()); - assertThat(logDataList.get(2).getSpanContext()).isEqualTo(span2.getSpanContext()); - } - - private static Span runWithSpan(String spanName, Runnable runnable) { - Span span = SdkTracerProvider.builder().build().get("tracer").spanBuilder(spanName).startSpan(); - try (Scope ignored = span.makeCurrent()) { - runnable.run(); - } finally { - span.end(); - } - return span; - } - - @Test - void logWithExtras() { - Instant start = Instant.now(); - logger.info("log message 1", new IllegalStateException("Error!")); - - List logDataList = logRecordExporter.getFinishedLogRecordItems(); - assertThat(logDataList).hasSize(1); - assertThat(logDataList.get(0)) - .hasResource(resource) - .hasInstrumentationScope(instrumentationScopeInfo) - .hasBody("log message 1") - .hasSeverity(Severity.INFO) - .hasSeverityText("INFO") - .hasAttributesSatisfyingExactly( - equalTo(SemanticAttributes.EXCEPTION_TYPE, IllegalStateException.class.getName()), - equalTo(SemanticAttributes.EXCEPTION_MESSAGE, "Error!"), - satisfies(SemanticAttributes.EXCEPTION_STACKTRACE, v -> v.contains("logWithExtras"))); - - assertThat(logDataList.get(0).getTimestampEpochNanos()) - .isGreaterThanOrEqualTo(TimeUnit.MILLISECONDS.toNanos(start.toEpochMilli())) - .isLessThanOrEqualTo(TimeUnit.MILLISECONDS.toNanos(Instant.now().toEpochMilli())); - } - - @Test - void logContextData() { - ThreadContext.put("key1", "val1"); - ThreadContext.put("key2", "val2"); - try { - logger.info("log message 1"); - } finally { - ThreadContext.clearMap(); - } - - List logDataList = logRecordExporter.getFinishedLogRecordItems(); - assertThat(logDataList).hasSize(1); - assertThat(logDataList.get(0)) - .hasResource(resource) - .hasInstrumentationScope(instrumentationScopeInfo) - .hasBody("log message 1") - .hasAttributesSatisfyingExactly( - equalTo(stringKey("log4j.context_data.key1"), "val1"), - equalTo(stringKey("log4j.context_data.key2"), "val2")); - } - - @Test - void logStringMapMessage() { - StringMapMessage message = new StringMapMessage(); - message.put("key1", "val1"); - message.put("key2", "val2"); - logger.info(message); - - List logDataList = logRecordExporter.getFinishedLogRecordItems(); - assertThat(logDataList).hasSize(1); - assertThat(logDataList.get(0)) - .hasResource(resource) - .hasInstrumentationScope(instrumentationScopeInfo) - .hasAttributesSatisfyingExactly( - equalTo(stringKey("log4j.map_message.key1"), "val1"), - equalTo(stringKey("log4j.map_message.key2"), "val2")); - } - - @Test - void logStringMapMessageWithSpecialAttribute() { - StringMapMessage message = new StringMapMessage(); - message.put("key1", "val1"); - message.put("message", "val2"); - logger.info(message); - - List logDataList = logRecordExporter.getFinishedLogRecordItems(); - assertThat(logDataList).hasSize(1); - assertThat(logDataList.get(0)) - .hasResource(resource) - .hasInstrumentationScope(instrumentationScopeInfo) - .hasBody("val2") - .hasAttributesSatisfyingExactly(equalTo(stringKey("log4j.map_message.key1"), "val1")); - } - - @Test - void testCaptureMarkerAttribute() { - String markerName = "aMarker"; - Marker marker = MarkerManager.getMarker(markerName); - - logger.info(marker, "Message"); - - List logDataList = logRecordExporter.getFinishedLogRecordItems(); - LogRecordData logData = logDataList.get(0); - assertThat(logData.getAttributes().get(stringKey("log4j.marker"))).isEqualTo(markerName); - } - - @Test - void logStructuredDataMessage() { - StructuredDataMessage message = new StructuredDataMessage("an id", "a message", "a type"); - message.put("key1", "val1"); - message.put("key2", "val2"); - logger.info(message); - - List logDataList = logRecordExporter.getFinishedLogRecordItems(); - assertThat(logDataList).hasSize(1); - assertThat(logDataList.get(0)) - .hasResource(resource) - .hasInstrumentationScope(instrumentationScopeInfo) - .hasBody("a message") - .hasAttributesSatisfyingExactly( - equalTo(stringKey("log4j.map_message.key1"), "val1"), - equalTo(stringKey("log4j.map_message.key2"), "val2")); - } } From 7f1bd8c99747f2cd98f4d50c866a879f9045fa7b Mon Sep 17 00:00:00 2001 From: Rupinder Singh Date: Wed, 14 Jun 2023 11:57:50 -0400 Subject: [PATCH 3/4] Update instrumentation/log4j/log4j-appender-2.17/library/src/main/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppender.java Co-authored-by: Trask Stalnaker --- .../log4j/appender/v2_17/OpenTelemetryAppender.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/instrumentation/log4j/log4j-appender-2.17/library/src/main/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppender.java b/instrumentation/log4j/log4j-appender-2.17/library/src/main/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppender.java index aa7e656c2e4a..cef3c084e8c4 100644 --- a/instrumentation/log4j/log4j-appender-2.17/library/src/main/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppender.java +++ b/instrumentation/log4j/log4j-appender-2.17/library/src/main/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppender.java @@ -98,7 +98,7 @@ public B setCaptureContextDataAttributes(String captureContextDataAttributes) { } @CanIgnoreReturnValue - public B setOpenTelemtry(OpenTelemetry openTelemetry) { + public B setOpenTelemetry(OpenTelemetry openTelemetry) { this.openTelemetry = openTelemetry; return asBuilder(); } From 645237b36fb5c9524a132570d75c2a8152d90129 Mon Sep 17 00:00:00 2001 From: Rupinder Singh Date: Wed, 14 Jun 2023 12:24:49 -0400 Subject: [PATCH 4/4] Added reset for GlobalOpenTelemetry in test cases, just in case --- .../OpenTelemetryAppenderConfigWithOpenTelemetryTest.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigWithOpenTelemetryTest.java b/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigWithOpenTelemetryTest.java index 5e8e7d3b4c3f..897bc7be916f 100644 --- a/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigWithOpenTelemetryTest.java +++ b/instrumentation/log4j/log4j-appender-2.17/library/src/test/java/io/opentelemetry/instrumentation/log4j/appender/v2_17/OpenTelemetryAppenderConfigWithOpenTelemetryTest.java @@ -7,6 +7,7 @@ import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat; +import io.opentelemetry.api.GlobalOpenTelemetry; import io.opentelemetry.api.OpenTelemetry; import io.opentelemetry.sdk.OpenTelemetrySdk; import io.opentelemetry.sdk.common.InstrumentationScopeInfo; @@ -38,6 +39,7 @@ static void setupAll() { .addLogRecordProcessor(SimpleLogRecordProcessor.create(logRecordExporter)) .build(); + GlobalOpenTelemetry.resetForTest(); openTelemetry = OpenTelemetrySdk.builder().setLoggerProvider(loggerProvider).build(); setOpenTelemetry(openTelemetry); } @@ -60,7 +62,7 @@ void initializeWithBuilder() { OpenTelemetryAppender appender = OpenTelemetryAppender.builder() .setName("OpenTelemetryAppender") - .setOpenTelemtry(openTelemetry) + .setOpenTelemetry(openTelemetry) .build(); appender.start();