diff --git a/conventions/src/main/kotlin/io.opentelemetry.instrumentation.javaagent-instrumentation.gradle.kts b/conventions/src/main/kotlin/io.opentelemetry.instrumentation.javaagent-instrumentation.gradle.kts index 190b152ddb57..bc5b0226042b 100644 --- a/conventions/src/main/kotlin/io.opentelemetry.instrumentation.javaagent-instrumentation.gradle.kts +++ b/conventions/src/main/kotlin/io.opentelemetry.instrumentation.javaagent-instrumentation.gradle.kts @@ -11,7 +11,6 @@ dependencies { add("muzzleBootstrap", "io.opentelemetry.javaagent:opentelemetry-javaagent-instrumentation-api") add("muzzleTooling", "io.opentelemetry.javaagent:opentelemetry-javaagent-extension-api") add("muzzleTooling", "io.opentelemetry.javaagent:opentelemetry-javaagent-tooling") - add("muzzleTooling", "org.slf4j:slf4j-simple") /* Dependencies added to this configuration will be found by the muzzle gradle plugin during code diff --git a/examples/extension/build.gradle b/examples/extension/build.gradle index 7e9ff3862967..762017c0d10c 100644 --- a/examples/extension/build.gradle +++ b/examples/extension/build.gradle @@ -110,7 +110,6 @@ dependencies { add("muzzleBootstrap", "io.opentelemetry.javaagent:opentelemetry-javaagent-instrumentation-api:${versions.opentelemetryJavaagentAlpha}") add("muzzleTooling", "io.opentelemetry.javaagent:opentelemetry-javaagent-extension-api:${versions.opentelemetryJavaagentAlpha}") add("muzzleTooling", "io.opentelemetry.javaagent:opentelemetry-javaagent-tooling:${versions.opentelemetryJavaagentAlpha}") - add("muzzleTooling", "org.slf4j:slf4j-simple:1.7.36") } //Produces a copy of upstream javaagent with this extension jar included inside it diff --git a/instrumentation/jetty-httpclient/jetty-httpclient-9.2/library/src/main/java/io/opentelemetry/instrumentation/jetty/httpclient/v9_2/internal/JettyClientHttpAttributesGetter.java b/instrumentation/jetty-httpclient/jetty-httpclient-9.2/library/src/main/java/io/opentelemetry/instrumentation/jetty/httpclient/v9_2/internal/JettyClientHttpAttributesGetter.java index bb922059036a..fc76c58376bf 100644 --- a/instrumentation/jetty-httpclient/jetty-httpclient-9.2/library/src/main/java/io/opentelemetry/instrumentation/jetty/httpclient/v9_2/internal/JettyClientHttpAttributesGetter.java +++ b/instrumentation/jetty-httpclient/jetty-httpclient-9.2/library/src/main/java/io/opentelemetry/instrumentation/jetty/httpclient/v9_2/internal/JettyClientHttpAttributesGetter.java @@ -113,10 +113,12 @@ private static Long getLongFromJettyHttpField(HttpField httpField) { try { longFromField = httpField != null ? Long.getLong(httpField.getValue()) : null; } catch (NumberFormatException t) { - logger.log( - FINE, - "Value {0} is not valid number format for header field: {1}", - new String[] {httpField.getValue(), httpField.getName()}); + if (logger.isLoggable(FINE)) { + logger.log( + FINE, + "Value {0} is not valid number format for header field: {1}", + new Object[] {httpField.getValue(), httpField.getName()}); + } } return longFromField; } diff --git a/instrumentation/micrometer/micrometer-1.5/library/src/main/java/io/opentelemetry/instrumentation/micrometer/v1_5/TimeUnitHelper.java b/instrumentation/micrometer/micrometer-1.5/library/src/main/java/io/opentelemetry/instrumentation/micrometer/v1_5/TimeUnitHelper.java index bb30accc7149..d7230455417b 100644 --- a/instrumentation/micrometer/micrometer-1.5/library/src/main/java/io/opentelemetry/instrumentation/micrometer/v1_5/TimeUnitHelper.java +++ b/instrumentation/micrometer/micrometer-1.5/library/src/main/java/io/opentelemetry/instrumentation/micrometer/v1_5/TimeUnitHelper.java @@ -45,10 +45,12 @@ static TimeUnit parseConfigValue(@Nullable String value, TimeUnit defaultUnit) { case "days": return TimeUnit.DAYS; default: - logger.log( - WARNING, - "Invalid base time unit: '{0}'; using '{1}' as the base time unit instead", - new String[] {value, getUnitString(defaultUnit)}); + if (logger.isLoggable(WARNING)) { + logger.log( + WARNING, + "Invalid base time unit: '{0}'; using '{1}' as the base time unit instead", + new Object[] {value, getUnitString(defaultUnit)}); + } return defaultUnit; } } diff --git a/javaagent-bootstrap/build.gradle.kts b/javaagent-bootstrap/build.gradle.kts index ae24a29059a7..1aa2108d5d39 100644 --- a/javaagent-bootstrap/build.gradle.kts +++ b/javaagent-bootstrap/build.gradle.kts @@ -8,6 +8,7 @@ group = "io.opentelemetry.javaagent" dependencies { implementation(project(":instrumentation-api")) implementation("org.slf4j:slf4j-api") + implementation("org.slf4j:slf4j-simple") testImplementation(project(":testing-common")) } diff --git a/javaagent-bootstrap/src/main/java/io/opentelemetry/javaagent/bootstrap/ExceptionLogger.java b/javaagent-bootstrap/src/main/java/io/opentelemetry/javaagent/bootstrap/ExceptionLogger.java index 23e89456d67b..950a546771df 100644 --- a/javaagent-bootstrap/src/main/java/io/opentelemetry/javaagent/bootstrap/ExceptionLogger.java +++ b/javaagent-bootstrap/src/main/java/io/opentelemetry/javaagent/bootstrap/ExceptionLogger.java @@ -5,6 +5,10 @@ package io.opentelemetry.javaagent.bootstrap; +import static java.util.logging.Level.FINE; + +import java.util.logging.Logger; + /** * Class used for exception handler logging. * @@ -12,5 +16,13 @@ */ public final class ExceptionLogger { + private static final Logger logger = Logger.getLogger(ExceptionLogger.class.getName()); + + /** See {@code io.opentelemetry.javaagent.tooling.ExceptionHandlers} for usages. */ + @SuppressWarnings("unused") + public static void logSuppressedError(String message, Throwable error) { + logger.log(FINE, message, error); + } + private ExceptionLogger() {} } diff --git a/javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/extension/matcher/SafeErasureMatcher.java b/javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/extension/matcher/SafeErasureMatcher.java index 814bbd6ad4e6..deb92fd40324 100644 --- a/javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/extension/matcher/SafeErasureMatcher.java +++ b/javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/extension/matcher/SafeErasureMatcher.java @@ -55,12 +55,14 @@ static TypeDescription safeAsErasure(TypeDefinition typeDefinition) { try { return typeDefinition.asErasure(); } catch (Throwable e) { - logger.log( - FINE, - "{0} trying to get erasure for target {1}: {2}", - new String[] { - e.getClass().getSimpleName(), safeTypeDefinitionName(typeDefinition), e.getMessage() - }); + if (logger.isLoggable(FINE)) { + logger.log( + FINE, + "{0} trying to get erasure for target {1}: {2}", + new Object[] { + e.getClass().getSimpleName(), safeTypeDefinitionName(typeDefinition), e.getMessage() + }); + } return null; } } diff --git a/javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/extension/matcher/SafeHasSuperTypeMatcher.java b/javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/extension/matcher/SafeHasSuperTypeMatcher.java index 5978c173ee5a..3a325e810499 100644 --- a/javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/extension/matcher/SafeHasSuperTypeMatcher.java +++ b/javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/extension/matcher/SafeHasSuperTypeMatcher.java @@ -102,12 +102,14 @@ static TypeDefinition safeGetSuperClass(TypeDefinition typeDefinition) { try { return typeDefinition.getSuperClass(); } catch (Throwable e) { - logger.log( - FINE, - "{0} trying to get super class for target {1}: {2}", - new String[] { - e.getClass().getSimpleName(), safeTypeDefinitionName(typeDefinition), e.getMessage() - }); + if (logger.isLoggable(FINE)) { + logger.log( + FINE, + "{0} trying to get super class for target {1}: {2}", + new Object[] { + e.getClass().getSimpleName(), safeTypeDefinitionName(typeDefinition), e.getMessage() + }); + } return null; } } @@ -191,12 +193,14 @@ public Iterator iterator() { } private static void logException(TypeDefinition typeDefinition, Throwable e) { - logger.log( - FINE, - "{0} trying to get interfaces for target {1}: {2}", - new String[] { - e.getClass().getSimpleName(), safeTypeDefinitionName(typeDefinition), e.getMessage() - }); + if (logger.isLoggable(FINE)) { + logger.log( + FINE, + "{0} trying to get interfaces for target {1}: {2}", + new Object[] { + e.getClass().getSimpleName(), safeTypeDefinitionName(typeDefinition), e.getMessage() + }); + } } } } diff --git a/javaagent-instrumentation-api/src/main/java/io/opentelemetry/javaagent/instrumentation/api/concurrent/PropagatedContext.java b/javaagent-instrumentation-api/src/main/java/io/opentelemetry/javaagent/instrumentation/api/concurrent/PropagatedContext.java index d0867a5fc452..a1b1908e6426 100644 --- a/javaagent-instrumentation-api/src/main/java/io/opentelemetry/javaagent/instrumentation/api/concurrent/PropagatedContext.java +++ b/javaagent-instrumentation-api/src/main/java/io/opentelemetry/javaagent/instrumentation/api/concurrent/PropagatedContext.java @@ -29,7 +29,7 @@ void setContext(Context context) { boolean result = contextUpdater.compareAndSet(this, null, context); if (!result) { Context currentPropagatedContext = contextUpdater.get(this); - if (currentPropagatedContext != context) { + if (currentPropagatedContext != context && logger.isLoggable(FINE)) { logger.log( FINE, "Failed to propagate context because previous propagated context is already set; new: {0}, old: {1}", diff --git a/javaagent-tooling/build.gradle.kts b/javaagent-tooling/build.gradle.kts index c3936c190552..02f542b633a8 100644 --- a/javaagent-tooling/build.gradle.kts +++ b/javaagent-tooling/build.gradle.kts @@ -50,7 +50,6 @@ dependencies { implementation("io.opentelemetry:opentelemetry-sdk-extension-jaeger-remote-sampler") api("net.bytebuddy:byte-buddy-dep") - implementation("org.slf4j:slf4j-api") annotationProcessor("com.google.auto.service:auto-service") compileOnly("com.google.auto.service:auto-service-annotations") @@ -64,6 +63,21 @@ dependencies { testImplementation("com.google.guava:guava") } +testing { + suites { + val testExceptionHandler by registering(JvmTestSuite::class) { + dependencies { + implementation(project(":javaagent-bootstrap")) + implementation(project(":javaagent-tooling")) + implementation("net.bytebuddy:byte-buddy-dep") + + // Used by byte-buddy but not brought in as a transitive dependency. + compileOnly("com.google.code.findbugs:annotations") + } + } + } +} + // Here we only include autoconfigure but don"t include OTLP exporters to ensure they are only in // the full distribution. We need to override the default exporter setting of OTLP as a result. tasks { @@ -78,6 +92,10 @@ tasks { isEnabled.set(false) } } + + check { + dependsOn(testing.suites) + } } // Mockito inline mocking uses byte-buddy but agent tooling currently uses byte-buddy-dep, which cannot be on the same diff --git a/javaagent-tooling/javaagent-tooling-java9/build.gradle.kts b/javaagent-tooling/javaagent-tooling-java9/build.gradle.kts index 112f34871554..d1a54f2e7e7f 100644 --- a/javaagent-tooling/javaagent-tooling-java9/build.gradle.kts +++ b/javaagent-tooling/javaagent-tooling-java9/build.gradle.kts @@ -9,7 +9,6 @@ dependencies { implementation(project(":javaagent-bootstrap")) implementation("net.bytebuddy:byte-buddy-dep") - implementation("org.slf4j:slf4j-api") // Used by byte-buddy but not brought in as a transitive dependency. compileOnly("com.google.code.findbugs:annotations") diff --git a/javaagent-tooling/javaagent-tooling-java9/src/main/java/io/opentelemetry/javaagent/tooling/ExposeAgentBootstrapListener.java b/javaagent-tooling/javaagent-tooling-java9/src/main/java/io/opentelemetry/javaagent/tooling/ExposeAgentBootstrapListener.java index ed616be8f48b..30a52e7fade0 100644 --- a/javaagent-tooling/javaagent-tooling-java9/src/main/java/io/opentelemetry/javaagent/tooling/ExposeAgentBootstrapListener.java +++ b/javaagent-tooling/javaagent-tooling-java9/src/main/java/io/opentelemetry/javaagent/tooling/ExposeAgentBootstrapListener.java @@ -5,23 +5,26 @@ package io.opentelemetry.javaagent.tooling; +import static java.util.logging.Level.FINE; + import io.opentelemetry.javaagent.bootstrap.AgentClassLoader; import java.lang.instrument.Instrumentation; import java.util.Collections; +import java.util.logging.Logger; import net.bytebuddy.agent.builder.AgentBuilder; import net.bytebuddy.description.type.TypeDescription; import net.bytebuddy.dynamic.DynamicType; import net.bytebuddy.dynamic.loading.ClassInjector; import net.bytebuddy.utility.JavaModule; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; /** * Ensures that transformed classes can read agent classes in bootstrap class loader and injected * classes in unnamed module of their class loader. */ public class ExposeAgentBootstrapListener extends AgentBuilder.Listener.Adapter { - private static final Logger logger = LoggerFactory.getLogger(ExposeAgentBootstrapListener.class); + private static final Logger logger = + Logger.getLogger(ExposeAgentBootstrapListener.class.getName()); + // unnamed module in bootstrap class loader private static final JavaModule agentBootstrapModule = JavaModule.of(AgentClassLoader.class.getModule()); @@ -52,7 +55,12 @@ private void exposeModule(JavaModule fromModule, JavaModule targetModule) { if (fromModule != JavaModule.UNSUPPORTED && fromModule.isNamed() && !fromModule.canRead(targetModule)) { - logger.debug("Adding module read from {} to {}", fromModule, targetModule); + + if (logger.isLoggable(FINE)) { + logger.log( + FINE, "Adding module read from {0} to {1}", new Object[] {fromModule, targetModule}); + } + ClassInjector.UsingInstrumentation.redefineModule( instrumentation, fromModule, diff --git a/javaagent-tooling/javaagent-tooling-java9/src/main/java/io/opentelemetry/javaagent/tooling/UnsafeInitializer.java b/javaagent-tooling/javaagent-tooling-java9/src/main/java/io/opentelemetry/javaagent/tooling/UnsafeInitializer.java index cbafc7e852cd..7f81277f154d 100644 --- a/javaagent-tooling/javaagent-tooling-java9/src/main/java/io/opentelemetry/javaagent/tooling/UnsafeInitializer.java +++ b/javaagent-tooling/javaagent-tooling-java9/src/main/java/io/opentelemetry/javaagent/tooling/UnsafeInitializer.java @@ -5,17 +5,18 @@ package io.opentelemetry.javaagent.tooling; +import static java.util.logging.Level.WARNING; + import io.opentelemetry.javaagent.bootstrap.AgentClassLoader; import java.lang.instrument.Instrumentation; import java.util.Collections; import java.util.HashMap; import java.util.Map; import java.util.Set; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +import java.util.logging.Logger; public class UnsafeInitializer { - private static final Logger logger = LoggerFactory.getLogger(UnsafeInitializer.class); + private static final Logger logger = Logger.getLogger(UnsafeInitializer.class.getName()); static void initialize(Instrumentation instrumentation, ClassLoader classLoader) { initialize(instrumentation, classLoader, true); @@ -56,7 +57,7 @@ private static void initialize( try { SunMiscUnsafeGenerator.generateUnsafe(unsafeClass, (AgentClassLoader) classLoader); } catch (Throwable throwable) { - logger.warn("Unsafe generation failed", throwable); + logger.log(WARNING, "Unsafe generation failed", throwable); } } diff --git a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/AgentInstaller.java b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/AgentInstaller.java index 147320a57573..0ca30d2e51c4 100644 --- a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/AgentInstaller.java +++ b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/AgentInstaller.java @@ -9,6 +9,8 @@ import static io.opentelemetry.javaagent.tooling.SafeServiceLoader.load; import static io.opentelemetry.javaagent.tooling.SafeServiceLoader.loadOrdered; import static io.opentelemetry.javaagent.tooling.Utils.getResourceName; +import static java.util.logging.Level.FINE; +import static java.util.logging.Level.SEVERE; import static net.bytebuddy.matcher.ElementMatchers.any; import io.opentelemetry.api.GlobalOpenTelemetry; @@ -40,6 +42,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.logging.Logger; import java.util.stream.Stream; import java.util.stream.StreamSupport; import javax.annotation.Nullable; @@ -49,8 +52,6 @@ import net.bytebuddy.description.type.TypeDescription; import net.bytebuddy.dynamic.DynamicType; import net.bytebuddy.utility.JavaModule; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; public class AgentInstaller { @@ -73,7 +74,7 @@ public class AgentInstaller { static { LoggingConfigurer.configureLogger(); - logger = LoggerFactory.getLogger(AgentInstaller.class); + logger = Logger.getLogger(AgentInstaller.class.getName()); addByteBuddyRawSetting(); // this needs to be done as early as possible - before the first Config.get() call @@ -94,7 +95,7 @@ public static void installBytebuddyAgent(Instrumentation inst) { List agentListeners = loadOrdered(AgentListener.class); installBytebuddyAgent(inst, agentListeners); } else { - logger.debug("Tracing is disabled, not installing instrumentations."); + logger.fine("Tracing is disabled, not installing instrumentations."); } } @@ -143,7 +144,7 @@ public static ResettableClassFileTransformer installBytebuddyAgent( agentBuilder = configureIgnoredTypes(config, agentBuilder); - if (logger.isDebugEnabled()) { + if (config.isAgentDebugEnabled()) { agentBuilder = agentBuilder .with(AgentBuilder.RedefinitionStrategy.RETRANSFORMATION) @@ -154,22 +155,27 @@ public static ResettableClassFileTransformer installBytebuddyAgent( int numberOfLoadedExtensions = 0; for (AgentExtension agentExtension : loadOrdered(AgentExtension.class)) { - logger.debug( - "Loading extension {} [class {}]", - agentExtension.extensionName(), - agentExtension.getClass().getName()); + if (logger.isLoggable(FINE)) { + logger.log( + FINE, + "Loading extension {0} [class {1}]", + new Object[] {agentExtension.extensionName(), agentExtension.getClass().getName()}); + } try { agentBuilder = agentExtension.extend(agentBuilder); numberOfLoadedExtensions++; } catch (Exception | LinkageError e) { - logger.error( - "Unable to load extension {} [class {}]", - agentExtension.extensionName(), - agentExtension.getClass().getName(), + logger.log( + SEVERE, + "Unable to load extension " + + agentExtension.extensionName() + + " [class " + + agentExtension.getClass().getName() + + "]", e); } } - logger.debug("Installed {} extension(s)", numberOfLoadedExtensions); + logger.log(FINE, "Installed {0} extension(s)", numberOfLoadedExtensions); ResettableClassFileTransformer resettableClassFileTransformer = agentBuilder.installOn(inst); ClassFileTransformerHolder.setClassFileTransformer(resettableClassFileTransformer); @@ -249,7 +255,7 @@ private static void runAfterAgentListeners( if (!shouldForceSynchronousAgentListenersCalls && isJavaBefore9() && isAppUsingCustomLogManager()) { - logger.debug("Custom JUL LogManager detected: delaying AgentListener#afterAgent() calls"); + logger.fine("Custom JUL LogManager detected: delaying AgentListener#afterAgent() calls"); registerClassLoadCallback( "java.util.logging.LogManager", new DelayedAfterAgentCallback(config, agentListeners, autoConfiguredSdk)); @@ -270,7 +276,7 @@ private static void addByteBuddyRawSetting() { System.setProperty(TypeDefinition.RAW_TYPES_PROPERTY, "true"); boolean rawTypes = TypeDescription.AbstractBase.RAW_TYPES; if (!rawTypes) { - logger.debug("Too late to enable {}", TypeDefinition.RAW_TYPES_PROPERTY); + logger.log(FINE, "Too late to enable {0}", TypeDefinition.RAW_TYPES_PROPERTY); } } finally { if (savedPropertyValue == null) { @@ -283,7 +289,8 @@ private static void addByteBuddyRawSetting() { static class RedefinitionLoggingListener implements AgentBuilder.RedefinitionStrategy.Listener { - private static final Logger logger = LoggerFactory.getLogger(RedefinitionLoggingListener.class); + private static final Logger logger = + Logger.getLogger(RedefinitionLoggingListener.class.getName()); @Override public void onBatch(int index, List> batch, List> types) {} @@ -291,9 +298,11 @@ public void onBatch(int index, List> batch, List> types) {} @Override public Iterable>> onError( int index, List> batch, Throwable throwable, List> types) { - if (logger.isDebugEnabled()) { - logger.debug( - "Exception while retransforming {} classes: {}", batch.size(), batch, throwable); + if (logger.isLoggable(FINE)) { + logger.log( + FINE, + "Exception while retransforming " + batch.size() + " classes: " + batch, + throwable); } return Collections.emptyList(); } @@ -315,11 +324,12 @@ public void onError( JavaModule module, boolean loaded, Throwable throwable) { - if (logger.isDebugEnabled()) { - logger.debug( - "Failed to handle {} for transformation on classloader {}", - typeName, - classLoader, + + if (logger.isLoggable(FINE)) { + logger.log( + FINE, + "Failed to handle {0} for transformation on classloader {1}", + new Object[] {typeName, classLoader}, throwable); } } @@ -331,7 +341,10 @@ public void onTransformation( JavaModule module, boolean loaded, DynamicType dynamicType) { - logger.debug("Transformed {} -- {}", typeDescription.getName(), classLoader); + if (logger.isLoggable(FINE)) { + logger.log( + FINE, "Transformed {0} -- {1}", new Object[] {typeDescription.getName(), classLoader}); + } } } @@ -388,7 +401,7 @@ private void runAgentListeners() { try { agentListener.afterAgent(config, autoConfiguredSdk); } catch (RuntimeException e) { - logger.error("Failed to execute {}", agentListener.getClass().getName(), e); + logger.log(SEVERE, "Failed to execute " + agentListener.getClass().getName(), e); } } } @@ -449,7 +462,7 @@ private static boolean isIgnored(Class c) { private static boolean isAppUsingCustomLogManager() { String jbossHome = System.getenv("JBOSS_HOME"); if (jbossHome != null) { - logger.debug("Found JBoss: {}; assuming app is using custom LogManager", jbossHome); + logger.log(FINE, "Found JBoss: {0}; assuming app is using custom LogManager", jbossHome); // JBoss/Wildfly is known to set a custom log manager after startup. // Originally we were checking for the presence of a jboss class, // but it seems some non-jboss applications have jboss classes on the classpath. @@ -460,15 +473,18 @@ private static boolean isAppUsingCustomLogManager() { String customLogManager = System.getProperty("java.util.logging.manager"); if (customLogManager != null) { - logger.debug( - "Detected custom LogManager configuration: java.util.logging.manager={}", + logger.log( + FINE, + "Detected custom LogManager configuration: java.util.logging.manager={0}", customLogManager); boolean onSysClasspath = ClassLoader.getSystemResource(getResourceName(customLogManager)) != null; - logger.debug( - "Class {} is on system classpath: {}delaying AgentInstaller#afterAgent()", - customLogManager, - onSysClasspath ? "not " : ""); + if (logger.isLoggable(FINE)) { + logger.log( + FINE, + "Class {0} is on system classpath: {1}delaying AgentInstaller#afterAgent()", + new Object[] {customLogManager, onSysClasspath ? "not " : ""}); + } // Some applications set java.util.logging.manager but never actually initialize the logger. // Check to see if the configured manager is on the system classpath. // If so, it should be safe to initialize AgentInstaller which will setup the log manager: @@ -482,8 +498,12 @@ private static boolean isAppUsingCustomLogManager() { private static void logVersionInfo() { VersionLogger.logAllVersions(); - logger.debug( - "{} loaded on {}", AgentInstaller.class.getName(), AgentInstaller.class.getClassLoader()); + if (logger.isLoggable(FINE)) { + logger.log( + FINE, + "{0} loaded on {1}", + new Object[] {AgentInstaller.class.getName(), AgentInstaller.class.getClassLoader()}); + } } private AgentInstaller() {} diff --git a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/SafeServiceLoader.java b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/SafeServiceLoader.java index b1eaa7be78a2..eba3c98f8fb6 100644 --- a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/SafeServiceLoader.java +++ b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/SafeServiceLoader.java @@ -5,18 +5,19 @@ package io.opentelemetry.javaagent.tooling; +import static java.util.logging.Level.FINE; + import io.opentelemetry.javaagent.extension.Ordered; import java.util.ArrayList; import java.util.Comparator; import java.util.Iterator; import java.util.List; import java.util.ServiceLoader; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +import java.util.logging.Logger; public final class SafeServiceLoader { - private static final Logger logger = LoggerFactory.getLogger(SafeServiceLoader.class); + private static final Logger logger = Logger.getLogger(SafeServiceLoader.class.getName()); /** * Delegates to {@link ServiceLoader#load(Class, ClassLoader)} and then eagerly iterates over @@ -36,7 +37,7 @@ public static List load(Class serviceClass) { try { result.add(iter.next()); } catch (UnsupportedClassVersionError e) { - logger.debug("Unable to load instrumentation class: {}", e.getMessage()); + logger.log(FINE, "Unable to load instrumentation class: {0}", e.getMessage()); } } return result; diff --git a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/VersionLogger.java b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/VersionLogger.java index e9cc1abfa279..fba6e4d370b8 100644 --- a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/VersionLogger.java +++ b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/VersionLogger.java @@ -5,23 +5,28 @@ package io.opentelemetry.javaagent.tooling; +import static java.util.logging.Level.FINE; +import static java.util.logging.Level.INFO; + import io.opentelemetry.instrumentation.api.InstrumentationVersion; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +import java.util.logging.Logger; public final class VersionLogger { - private static final Logger logger = LoggerFactory.getLogger(VersionLogger.class); + private static final Logger logger = Logger.getLogger(VersionLogger.class.getName()); public static void logAllVersions() { - logger.info("opentelemetry-javaagent - version: {}", InstrumentationVersion.VERSION); - if (logger.isDebugEnabled()) { - logger.debug( - "Running on Java {}. JVM {} - {} - {}", - System.getProperty("java.version"), - System.getProperty("java.vm.name"), - System.getProperty("java.vm.vendor"), - System.getProperty("java.vm.version")); + logger.log(INFO, "opentelemetry-javaagent - version: {0}", InstrumentationVersion.VERSION); + if (logger.isLoggable(FINE)) { + logger.log( + FINE, + "Running on Java {0}. JVM {1} - {2} - {3}", + new Object[] { + System.getProperty("java.version"), + System.getProperty("java.vm.name"), + System.getProperty("java.vm.vendor"), + System.getProperty("java.vm.version") + }); } } diff --git a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/bytebuddy/ExceptionHandlers.java b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/bytebuddy/ExceptionHandlers.java index 75eb1f833831..ca5c563e8250 100644 --- a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/bytebuddy/ExceptionHandlers.java +++ b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/bytebuddy/ExceptionHandlers.java @@ -13,21 +13,16 @@ import org.objectweb.asm.Label; import org.objectweb.asm.MethodVisitor; import org.objectweb.asm.Opcodes; -import org.objectweb.asm.Type; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; public final class ExceptionHandlers { - private static final String LOG_FACTORY_NAME = LoggerFactory.class.getName().replace('.', '/'); - private static final String LOGGER_NAME = Logger.class.getName().replace('.', '/'); - // Bootstrap ExceptionHandler.class will always be resolvable, so we'll use it in the log name - private static final String HANDLER_NAME = ExceptionLogger.class.getName().replace('.', '/'); + // Bootstrap ExceptionLogger.class will always be resolvable, so we'll use it in the log name + private static final String LOGGER_NAME = ExceptionLogger.class.getName().replace('.', '/'); private static final ExceptionHandler EXCEPTION_STACK_HANDLER = new ExceptionHandler.Simple( new StackManipulation() { - // Pops one Throwable off the stack. Maxes the stack to at least 3. - private final StackManipulation.Size size = new StackManipulation.Size(-1, 3); + // Pops one Throwable off the stack. Maxes the stack to at least 2 (throwable, string). + private final StackManipulation.Size size = new StackManipulation.Size(-1, 2); @Override public boolean isValid() { @@ -41,8 +36,7 @@ public StackManipulation.Size apply(MethodVisitor mv, Implementation.Context con // writes the following bytecode: // try { - // org.slf4j.LoggerFactory.getLogger((Class)ExceptionLogger.class) - // .debug("exception in instrumentation", t); + // ExceptionLogger.logSuppressedError("exception in instrumentation", t); // } catch (Throwable t2) { // } Label logStart = new Label(); @@ -57,30 +51,23 @@ public StackManipulation.Size apply(MethodVisitor mv, Implementation.Context con // stack: (top) throwable mv.visitLabel(logStart); - mv.visitLdcInsn(Type.getType("L" + HANDLER_NAME + ";")); - mv.visitMethodInsn( - Opcodes.INVOKESTATIC, - LOG_FACTORY_NAME, - "getLogger", - "(Ljava/lang/Class;)L" + LOGGER_NAME + ";", - /* isInterface= */ false); - mv.visitInsn(Opcodes.SWAP); // stack: (top) throwable,logger mv.visitLdcInsn( "Failed to handle exception in instrumentation for " + name + " on " + classLoader); - mv.visitInsn(Opcodes.SWAP); // stack: (top) throwable,string,logger + mv.visitInsn(Opcodes.SWAP); // stack: (top) throwable,string + mv.visitMethodInsn( - Opcodes.INVOKEINTERFACE, + Opcodes.INVOKESTATIC, LOGGER_NAME, - "debug", + "logSuppressedError", "(Ljava/lang/String;Ljava/lang/Throwable;)V", - /* isInterface= */ true); + /* isInterface= */ false); mv.visitLabel(logEnd); mv.visitJumpInsn(Opcodes.GOTO, handlerExit); - // if the runtime can't reach our ExceptionHandler or logger, + // if the runtime can't reach our ExceptionLogger, // silently eat the exception mv.visitLabel(eatException); if (frames) { diff --git a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/bytebuddy/LoggingFailSafeMatcher.java b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/bytebuddy/LoggingFailSafeMatcher.java index bbcc3381876e..3e5dad1f652d 100644 --- a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/bytebuddy/LoggingFailSafeMatcher.java +++ b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/bytebuddy/LoggingFailSafeMatcher.java @@ -5,10 +5,10 @@ package io.opentelemetry.javaagent.tooling.bytebuddy; +import java.util.logging.Level; +import java.util.logging.Logger; import javax.annotation.Nullable; import net.bytebuddy.matcher.ElementMatcher; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; /** * A fail-safe matcher catches exceptions that are thrown by a delegate matcher and returns {@code @@ -21,7 +21,7 @@ */ public class LoggingFailSafeMatcher extends ElementMatcher.Junction.AbstractBase { - private static final Logger logger = LoggerFactory.getLogger(LoggingFailSafeMatcher.class); + private static final Logger logger = Logger.getLogger(LoggingFailSafeMatcher.class.getName()); /** The delegate matcher that might throw an exception. */ private final ElementMatcher matcher; @@ -45,7 +45,7 @@ public boolean matches(T target) { try { return matcher.matches(target); } catch (Throwable e) { - logger.debug(description, e); + logger.log(Level.FINE, description, e); return false; } } diff --git a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/config/ConfigInitializer.java b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/config/ConfigInitializer.java index c1c83ec46358..e5241ef786c1 100644 --- a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/config/ConfigInitializer.java +++ b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/config/ConfigInitializer.java @@ -6,6 +6,7 @@ package io.opentelemetry.javaagent.tooling.config; import static io.opentelemetry.javaagent.tooling.SafeServiceLoader.loadOrdered; +import static java.util.logging.Level.SEVERE; import io.opentelemetry.instrumentation.api.config.Config; import io.opentelemetry.javaagent.extension.config.ConfigPropertySource; @@ -16,11 +17,10 @@ import java.io.InputStreamReader; import java.nio.charset.StandardCharsets; import java.util.Properties; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +import java.util.logging.Logger; public final class ConfigInitializer { - private static final Logger logger = LoggerFactory.getLogger(ConfigInitializer.class); + private static final Logger logger = Logger.getLogger(ConfigInitializer.class.getName()); // visible for testing static final String CONFIGURATION_FILE_PROPERTY = "otel.javaagent.configuration-file"; @@ -75,7 +75,7 @@ static Properties loadConfigurationFile() { // Configuration properties file is optional File configurationFile = new File(configurationFilePath); if (!configurationFile.exists()) { - logger.error("Configuration file '{}' not found.", configurationFilePath); + logger.log(SEVERE, "Configuration file '{0}' not found.", configurationFilePath); return properties; } @@ -83,10 +83,12 @@ static Properties loadConfigurationFile() { new InputStreamReader(new FileInputStream(configurationFile), StandardCharsets.UTF_8)) { properties.load(reader); } catch (FileNotFoundException fnf) { - logger.error("Configuration file '{}' not found.", configurationFilePath); + logger.log(SEVERE, "Configuration file '{0}' not found.", configurationFilePath); } catch (IOException ioe) { - logger.error( - "Configuration file '{}' cannot be accessed or correctly parsed.", configurationFilePath); + logger.log( + SEVERE, + "Configuration file '{0}' cannot be accessed or correctly parsed.", + configurationFilePath); } return properties; diff --git a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/config/MethodsConfigurationParser.java b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/config/MethodsConfigurationParser.java index 822b0361851c..d73c47d130c2 100644 --- a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/config/MethodsConfigurationParser.java +++ b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/config/MethodsConfigurationParser.java @@ -5,17 +5,18 @@ package io.opentelemetry.javaagent.tooling.config; +import static java.util.logging.Level.WARNING; + import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Set; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +import java.util.logging.Logger; public final class MethodsConfigurationParser { - private static final Logger logger = LoggerFactory.getLogger(MethodsConfigurationParser.class); + private static final Logger logger = Logger.getLogger(MethodsConfigurationParser.class.getName()); static final String PACKAGE_CLASS_NAME_REGEX = "[\\w.$]+"; private static final String METHOD_LIST_REGEX = "\\s*(?:\\w+\\s*,)*\\s*(?:\\w+\\s*,?)\\s*"; @@ -41,8 +42,9 @@ public static Map> parse(String configString) { if (configString == null || configString.trim().isEmpty()) { return Collections.emptyMap(); } else if (!validateConfigString(configString)) { - logger.warn( - "Invalid trace method config '{}'. Must match 'package.Class$Name[method1,method2];*'.", + logger.log( + WARNING, + "Invalid trace method config '{0}'. Must match 'package.Class$Name[method1,method2];*'.", configString); return Collections.emptyMap(); } else { diff --git a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/FieldBackedImplementationInstaller.java b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/FieldBackedImplementationInstaller.java index 18e6806206fd..d4450373fc35 100644 --- a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/FieldBackedImplementationInstaller.java +++ b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/FieldBackedImplementationInstaller.java @@ -6,6 +6,7 @@ package io.opentelemetry.javaagent.tooling.field; import static io.opentelemetry.javaagent.extension.matcher.AgentElementMatchers.hasSuperType; +import static java.util.logging.Level.FINEST; import static net.bytebuddy.matcher.ElementMatchers.isAbstract; import static net.bytebuddy.matcher.ElementMatchers.named; import static net.bytebuddy.matcher.ElementMatchers.not; @@ -174,11 +175,21 @@ public AgentBuilder.Identified.Extendable injectFields( */ synchronized (INSTALLED_VIRTUAL_FIELD_MATCHERS) { if (INSTALLED_VIRTUAL_FIELD_MATCHERS.contains(entry)) { - logger.trace("Skipping builder for {} {}", instrumenterClass.getName(), entry); + if (logger.isLoggable(FINEST)) { + logger.log( + FINEST, + "Skipping builder for {0} {1}", + new Object[] {instrumenterClass.getName(), entry}); + } continue; } - logger.trace("Making builder for {} {}", instrumenterClass.getName(), entry); + if (logger.isLoggable(FINEST)) { + logger.log( + FINEST, + "Making builder for {0} {1}", + new Object[] {instrumenterClass.getName(), entry}); + } INSTALLED_VIRTUAL_FIELD_MATCHERS.add(entry); /* diff --git a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/VirtualFieldFindRewriter.java b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/VirtualFieldFindRewriter.java index 048d495e5956..835c2699492f 100644 --- a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/VirtualFieldFindRewriter.java +++ b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/VirtualFieldFindRewriter.java @@ -5,6 +5,8 @@ package io.opentelemetry.javaagent.tooling.field; +import static java.util.logging.Level.FINEST; + import io.opentelemetry.instrumentation.api.field.VirtualField; import io.opentelemetry.javaagent.tooling.TransformSafeLogger; import io.opentelemetry.javaagent.tooling.Utils; @@ -95,8 +97,10 @@ public void visitMethodInsn( if (Utils.getInternalName(FIND_VIRTUAL_FIELD_METHOD.getDeclaringClass()).equals(owner) && FIND_VIRTUAL_FIELD_METHOD.getName().equals(name) && Type.getMethodDescriptor(FIND_VIRTUAL_FIELD_METHOD).equals(descriptor)) { - logger.trace( - "Found VirtualField#find() access in {}", instrumentationModuleClass.getName()); + logger.log( + FINEST, + "Found VirtualField#find() access in {0}", + instrumentationModuleClass.getName()); /* The idea here is that the rest if this method visitor collects last three instructions in `insnStack` variable. Once we get here we check if those last three instructions constitute call that looks like @@ -111,12 +115,11 @@ public void visitMethodInsn( String typeName = ((Type) stack[1]).getClassName(); TypeDescription virtualFieldImplementationClass = virtualFieldImplementations.find(typeName, fieldTypeName); - if (logger.isTraceEnabled()) { - logger.trace( - "Rewriting VirtualField#find() for instrumenter {}: {} -> {}", - instrumentationModuleClass.getName(), - typeName, - fieldTypeName); + if (logger.isLoggable(FINEST)) { + logger.log( + FINEST, + "Rewriting VirtualField#find() for instrumenter {0}: {1} -> {2}", + new Object[] {instrumentationModuleClass.getName(), typeName, fieldTypeName}); } if (virtualFieldImplementationClass == null) { throw new IllegalStateException( diff --git a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/VirtualFieldImplementationInstallerFactory.java b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/VirtualFieldImplementationInstallerFactory.java index b2af24f0b504..3da93ab694c2 100644 --- a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/VirtualFieldImplementationInstallerFactory.java +++ b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/VirtualFieldImplementationInstallerFactory.java @@ -5,6 +5,8 @@ package io.opentelemetry.javaagent.tooling.field; +import static java.util.logging.Level.FINE; + import io.opentelemetry.instrumentation.api.internal.RuntimeVirtualFieldSupplier; import io.opentelemetry.javaagent.extension.instrumentation.InstrumentationModule; import io.opentelemetry.javaagent.tooling.TransformSafeLogger; @@ -26,8 +28,9 @@ public VirtualFieldImplementationInstaller create(InstrumentationModule instrume if (instrumentationModule instanceof InstrumentationModuleMuzzle) { ((InstrumentationModuleMuzzle) instrumentationModule).registerMuzzleVirtualFields(builder); } else { - logger.debug( - "Found InstrumentationModule which does not implement InstrumentationModuleMuzzle: {}", + logger.log( + FINE, + "Found InstrumentationModule which does not implement InstrumentationModuleMuzzle: {0}", instrumentationModule); } VirtualFieldMappings mappings = builder.build(); diff --git a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/ignore/IgnoredClassLoadersMatcher.java b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/ignore/IgnoredClassLoadersMatcher.java index 75bb87f56153..1ef23bc20574 100644 --- a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/ignore/IgnoredClassLoadersMatcher.java +++ b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/ignore/IgnoredClassLoadersMatcher.java @@ -5,16 +5,17 @@ package io.opentelemetry.javaagent.tooling.ignore; +import static java.util.logging.Level.FINE; + import io.opentelemetry.instrumentation.api.cache.Cache; import io.opentelemetry.javaagent.bootstrap.PatchLogger; import io.opentelemetry.javaagent.tooling.util.Trie; +import java.util.logging.Logger; import net.bytebuddy.dynamic.loading.ClassLoadingStrategy; import net.bytebuddy.matcher.ElementMatcher; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; public class IgnoredClassLoadersMatcher extends ElementMatcher.Junction.AbstractBase { - private static final Logger logger = LoggerFactory.getLogger(IgnoredClassLoadersMatcher.class); + private static final Logger logger = Logger.getLogger(IgnoredClassLoadersMatcher.class.getName()); /* Cache of classloader-instance -> (true|false). True = skip instrumentation. False = safe to instrument. */ private static final Cache skipCache = Cache.weak(); @@ -70,7 +71,7 @@ public boolean matches(ClassLoader cl) { private static boolean delegatesToBootstrap(ClassLoader loader) { boolean delegates = true; if (!loadsExpectedClass(loader, PatchLogger.class)) { - logger.debug("loader {} failed to delegate bootstrap agent class", loader); + logger.log(FINE, "loader {0} failed to delegate bootstrap agent class", loader); delegates = false; } return delegates; diff --git a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/instrumentation/InstrumentationLoader.java b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/instrumentation/InstrumentationLoader.java index 318bc6fe0b22..e5c49601c1e0 100644 --- a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/instrumentation/InstrumentationLoader.java +++ b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/instrumentation/InstrumentationLoader.java @@ -6,18 +6,19 @@ package io.opentelemetry.javaagent.tooling.instrumentation; import static io.opentelemetry.javaagent.tooling.SafeServiceLoader.loadOrdered; +import static java.util.logging.Level.FINE; +import static java.util.logging.Level.SEVERE; import com.google.auto.service.AutoService; import io.opentelemetry.javaagent.bootstrap.InstrumentationHolder; import io.opentelemetry.javaagent.extension.instrumentation.InstrumentationModule; import io.opentelemetry.javaagent.tooling.AgentExtension; +import java.util.logging.Logger; import net.bytebuddy.agent.builder.AgentBuilder; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; @AutoService(AgentExtension.class) public class InstrumentationLoader implements AgentExtension { - private static final Logger logger = LoggerFactory.getLogger(InstrumentationLoader.class); + private static final Logger logger = Logger.getLogger(InstrumentationLoader.class.getName()); private final InstrumentationModuleInstaller instrumentationModuleInstaller = new InstrumentationModuleInstaller(InstrumentationHolder.getInstrumentation()); @@ -26,22 +27,30 @@ public class InstrumentationLoader implements AgentExtension { public AgentBuilder extend(AgentBuilder agentBuilder) { int numberOfLoadedModules = 0; for (InstrumentationModule instrumentationModule : loadOrdered(InstrumentationModule.class)) { - logger.debug( - "Loading instrumentation {} [class {}]", - instrumentationModule.instrumentationName(), - instrumentationModule.getClass().getName()); + if (logger.isLoggable(FINE)) { + logger.log( + FINE, + "Loading instrumentation {0} [class {1}]", + new Object[] { + instrumentationModule.instrumentationName(), + instrumentationModule.getClass().getName() + }); + } try { agentBuilder = instrumentationModuleInstaller.install(instrumentationModule, agentBuilder); numberOfLoadedModules++; } catch (Exception | LinkageError e) { - logger.error( - "Unable to load instrumentation {} [class {}]", - instrumentationModule.instrumentationName(), - instrumentationModule.getClass().getName(), + logger.log( + SEVERE, + "Unable to load instrumentation " + + instrumentationModule.instrumentationName() + + " [class " + + instrumentationModule.getClass().getName() + + "]", e); } } - logger.debug("Installed {} instrumenter(s)", numberOfLoadedModules); + logger.log(FINE, "Installed {0} instrumenter(s)", numberOfLoadedModules); return agentBuilder; } diff --git a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/instrumentation/InstrumentationModuleInstaller.java b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/instrumentation/InstrumentationModuleInstaller.java index f7af0c60d6e4..d84d34c21c7e 100644 --- a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/instrumentation/InstrumentationModuleInstaller.java +++ b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/instrumentation/InstrumentationModuleInstaller.java @@ -5,6 +5,8 @@ package io.opentelemetry.javaagent.tooling.instrumentation; +import static java.util.logging.Level.FINE; +import static java.util.logging.Level.WARNING; import static net.bytebuddy.dynamic.loading.ClassLoadingStrategy.BOOTSTRAP_LOADER; import static net.bytebuddy.matcher.ElementMatchers.isAnnotatedWith; import static net.bytebuddy.matcher.ElementMatchers.named; @@ -27,18 +29,17 @@ import java.security.ProtectionDomain; import java.util.List; import java.util.concurrent.atomic.AtomicBoolean; +import java.util.logging.Logger; import net.bytebuddy.agent.builder.AgentBuilder; import net.bytebuddy.description.annotation.AnnotationSource; import net.bytebuddy.description.type.TypeDescription; import net.bytebuddy.matcher.ElementMatcher; import net.bytebuddy.utility.JavaModule; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; public final class InstrumentationModuleInstaller { private static final TransformSafeLogger logger = TransformSafeLogger.getLogger(InstrumentationModule.class); - private static final Logger muzzleLogger = LoggerFactory.getLogger("muzzleMatcher"); + private static final Logger muzzleLogger = Logger.getLogger("muzzleMatcher"); // Added here instead of AgentInstaller's ignores because it's relatively // expensive. https://github.com/DataDog/dd-trace-java/pull/1045 @@ -56,7 +57,8 @@ public InstrumentationModuleInstaller(Instrumentation instrumentation) { AgentBuilder install( InstrumentationModule instrumentationModule, AgentBuilder parentAgentBuilder) { if (!instrumentationModule.isEnabled()) { - logger.debug("Instrumentation {} is disabled", instrumentationModule.instrumentationName()); + logger.log( + FINE, "Instrumentation {0} is disabled", instrumentationModule.instrumentationName()); return parentAgentBuilder; } List helperClassNames = @@ -66,8 +68,9 @@ AgentBuilder install( List typeInstrumentations = instrumentationModule.typeInstrumentations(); if (typeInstrumentations.isEmpty()) { if (!helperClassNames.isEmpty() || !helperResourceBuilder.getResources().isEmpty()) { - logger.warn( - "Helper classes and resources won't be injected if no types are instrumented: {}", + logger.log( + WARNING, + "Helper classes and resources won't be injected if no types are instrumented: {0}", instrumentationModule.instrumentationName()); } @@ -151,24 +154,30 @@ private boolean doesMatch(ClassLoader classLoader) { if (!isMatch) { MuzzleFailureCounter.inc(); - if (muzzleLogger.isWarnEnabled()) { - muzzleLogger.warn( - "Instrumentation skipped, mismatched references were found: {} [class {}] on {}", - instrumentationModule.instrumentationName(), - instrumentationModule.getClass().getName(), - classLoader); + if (muzzleLogger.isLoggable(WARNING)) { + muzzleLogger.log( + WARNING, + "Instrumentation skipped, mismatched references were found: {0} [class {1}] on {2}", + new Object[] { + instrumentationModule.instrumentationName(), + instrumentationModule.getClass().getName(), + classLoader + }); List mismatches = muzzle.getMismatchedReferenceSources(classLoader); for (Mismatch mismatch : mismatches) { - muzzleLogger.warn("-- {}", mismatch); + muzzleLogger.log(WARNING, "-- {0}", mismatch); } } } else { - if (logger.isDebugEnabled()) { - logger.debug( - "Applying instrumentation: {} [class {}] on {}", - instrumentationModule.instrumentationName(), - instrumentationModule.getClass().getName(), - classLoader); + if (logger.isLoggable(FINE)) { + logger.log( + FINE, + "Applying instrumentation: {0} [class {1}] on {2}", + new Object[] { + instrumentationModule.instrumentationName(), + instrumentationModule.getClass().getName(), + classLoader + }); } } diff --git a/javaagent-tooling/src/test/groovy/io/opentelemetry/javaagent/tooling/bytebuddy/matcher/ExtendsClassMatcherTest.groovy b/javaagent-tooling/src/test/groovy/io/opentelemetry/javaagent/tooling/bytebuddy/matcher/ExtendsClassMatcherTest.groovy index 57a7436dd19c..f1163a53ba2d 100644 --- a/javaagent-tooling/src/test/groovy/io/opentelemetry/javaagent/tooling/bytebuddy/matcher/ExtendsClassMatcherTest.groovy +++ b/javaagent-tooling/src/test/groovy/io/opentelemetry/javaagent/tooling/bytebuddy/matcher/ExtendsClassMatcherTest.groovy @@ -56,9 +56,7 @@ class ExtendsClassMatcherTest extends Specification { noExceptionThrown() 1 * type.getModifiers() >> Opcodes.ACC_ABSTRACT 1 * type.asGenericType() >> typeGeneric - 1 * type.getTypeName() >> "type-name" 1 * typeGeneric.asErasure() >> { throw new Exception("asErasure exception") } - 1 * typeGeneric.getTypeName() >> "typeGeneric-name" 1 * type.getSuperClass() >> { throw new Exception("getSuperClass exception") } 0 * _ } diff --git a/javaagent-tooling/src/test/groovy/io/opentelemetry/javaagent/tooling/bytebuddy/matcher/HasInterfaceMatcherTest.groovy b/javaagent-tooling/src/test/groovy/io/opentelemetry/javaagent/tooling/bytebuddy/matcher/HasInterfaceMatcherTest.groovy index 4db87126568f..f0ba1abb214f 100644 --- a/javaagent-tooling/src/test/groovy/io/opentelemetry/javaagent/tooling/bytebuddy/matcher/HasInterfaceMatcherTest.groovy +++ b/javaagent-tooling/src/test/groovy/io/opentelemetry/javaagent/tooling/bytebuddy/matcher/HasInterfaceMatcherTest.groovy @@ -64,11 +64,9 @@ class HasInterfaceMatcherTest extends Specification { 1 * type.isInterface() >> true 1 * type.asGenericType() >> typeGeneric 1 * typeGeneric.asErasure() >> { throw new Exception("asErasure exception") } - 1 * typeGeneric.getTypeName() >> "typeGeneric-name" 1 * type.getInterfaces() >> interfaces 1 * interfaces.iterator() >> it 1 * type.getSuperClass() >> { throw new Exception("getSuperClass exception") } - 2 * type.getTypeName() >> "type-name" 0 * _ } } diff --git a/javaagent-tooling/src/test/groovy/io/opentelemetry/javaagent/tooling/bytebuddy/matcher/ImplementsInterfaceMatcherTest.groovy b/javaagent-tooling/src/test/groovy/io/opentelemetry/javaagent/tooling/bytebuddy/matcher/ImplementsInterfaceMatcherTest.groovy index dcf6aa018745..21b4512509c0 100644 --- a/javaagent-tooling/src/test/groovy/io/opentelemetry/javaagent/tooling/bytebuddy/matcher/ImplementsInterfaceMatcherTest.groovy +++ b/javaagent-tooling/src/test/groovy/io/opentelemetry/javaagent/tooling/bytebuddy/matcher/ImplementsInterfaceMatcherTest.groovy @@ -62,10 +62,8 @@ class ImplementsInterfaceMatcherTest extends Specification { 1 * type.isInterface() >> true 1 * type.asGenericType() >> typeGeneric 1 * typeGeneric.asErasure() >> { throw new Exception("asErasure exception") } - 1 * typeGeneric.getTypeName() >> "typeGeneric-name" 1 * type.getInterfaces() >> { throw new Exception("getInterfaces exception") } 1 * type.getSuperClass() >> { throw new Exception("getSuperClass exception") } - 2 * type.getTypeName() >> "type-name" 0 * _ } @@ -86,10 +84,8 @@ class ImplementsInterfaceMatcherTest extends Specification { 1 * type.isInterface() >> true 1 * type.asGenericType() >> typeGeneric 1 * typeGeneric.asErasure() >> { throw new Exception("asErasure exception") } - 1 * typeGeneric.getTypeName() >> "typeGeneric-name" 1 * type.getInterfaces() >> interfaces 1 * interfaces.iterator() >> it - 2 * type.getTypeName() >> "type-name" 1 * type.getSuperClass() >> { throw new Exception("getSuperClass exception") } 0 * _ } diff --git a/javaagent-tooling/src/test/groovy/io/opentelemetry/javaagent/tooling/bytebuddy/matcher/SafeHasSuperTypeMatcherTest.groovy b/javaagent-tooling/src/test/groovy/io/opentelemetry/javaagent/tooling/bytebuddy/matcher/SafeHasSuperTypeMatcherTest.groovy index 9d81bae7c593..bc3e1d4b4e40 100644 --- a/javaagent-tooling/src/test/groovy/io/opentelemetry/javaagent/tooling/bytebuddy/matcher/SafeHasSuperTypeMatcherTest.groovy +++ b/javaagent-tooling/src/test/groovy/io/opentelemetry/javaagent/tooling/bytebuddy/matcher/SafeHasSuperTypeMatcherTest.groovy @@ -61,10 +61,8 @@ class SafeHasSuperTypeMatcherTest extends Specification { noExceptionThrown() 1 * type.asGenericType() >> typeGeneric 1 * typeGeneric.asErasure() >> { throw new Exception("asErasure exception") } - 1 * typeGeneric.getTypeName() >> "typeGeneric-name" 1 * type.getInterfaces() >> { throw new Exception("getInterfaces exception") } 1 * type.getSuperClass() >> { throw new Exception("getSuperClass exception") } - 2 * type.getTypeName() >> "type-name" 0 * _ } @@ -86,6 +84,5 @@ class SafeHasSuperTypeMatcherTest extends Specification { 1 * interfaces.iterator() >> it 1 * type.asGenericType() >> typeGeneric 1 * typeGeneric.asErasure() >> { throw new Exception("asErasure exception") } - 1 * typeGeneric.getTypeName() >> "typeGeneric-name" } } diff --git a/javaagent-tooling/src/test/java/io/opentelemetry/javaagent/test/BadAdvice.java b/javaagent-tooling/src/testExceptionHandler/java/io/opentelemetry/javaagent/tooling/bytebuddy/BadAdvice.java similarity index 90% rename from javaagent-tooling/src/test/java/io/opentelemetry/javaagent/test/BadAdvice.java rename to javaagent-tooling/src/testExceptionHandler/java/io/opentelemetry/javaagent/tooling/bytebuddy/BadAdvice.java index 32b44335067e..5f3997319839 100644 --- a/javaagent-tooling/src/test/java/io/opentelemetry/javaagent/test/BadAdvice.java +++ b/javaagent-tooling/src/testExceptionHandler/java/io/opentelemetry/javaagent/tooling/bytebuddy/BadAdvice.java @@ -3,7 +3,7 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.javaagent.test; +package io.opentelemetry.javaagent.tooling.bytebuddy; import net.bytebuddy.asm.Advice; diff --git a/javaagent-tooling/src/test/java/io/opentelemetry/javaagent/test/ExceptionHandlerTest.java b/javaagent-tooling/src/testExceptionHandler/java/io/opentelemetry/javaagent/tooling/bytebuddy/ExceptionHandlerTest.java similarity index 83% rename from javaagent-tooling/src/test/java/io/opentelemetry/javaagent/test/ExceptionHandlerTest.java rename to javaagent-tooling/src/testExceptionHandler/java/io/opentelemetry/javaagent/tooling/bytebuddy/ExceptionHandlerTest.java index 8149eaaed78c..91f7b1291d4a 100644 --- a/javaagent-tooling/src/test/java/io/opentelemetry/javaagent/test/ExceptionHandlerTest.java +++ b/javaagent-tooling/src/testExceptionHandler/java/io/opentelemetry/javaagent/tooling/bytebuddy/ExceptionHandlerTest.java @@ -3,7 +3,7 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.javaagent.test; +package io.opentelemetry.javaagent.tooling.bytebuddy; import static net.bytebuddy.matcher.ElementMatchers.isMethod; import static net.bytebuddy.matcher.ElementMatchers.named; @@ -12,14 +12,11 @@ import static org.assertj.core.api.Assertions.assertThatCode; import static org.assertj.core.api.Assertions.assertThatThrownBy; -import ch.qos.logback.classic.Level; -import ch.qos.logback.classic.Logger; -import ch.qos.logback.classic.spi.ILoggingEvent; -import ch.qos.logback.core.read.ListAppender; import io.opentelemetry.javaagent.bootstrap.ExceptionLogger; -import io.opentelemetry.javaagent.tooling.bytebuddy.ExceptionHandlers; import java.net.URL; import java.net.URLClassLoader; +import java.util.logging.Level; +import java.util.logging.Logger; import net.bytebuddy.agent.ByteBuddyAgent; import net.bytebuddy.agent.builder.AgentBuilder; import net.bytebuddy.agent.builder.ResettableClassFileTransformer; @@ -31,7 +28,7 @@ class ExceptionHandlerTest { - private static final ListAppender testAppender = new ListAppender<>(); + private static final TestHandler testHandler = new TestHandler(); private static ResettableClassFileTransformer transformer; @BeforeAll @@ -61,31 +58,32 @@ static void setUp() { ByteBuddyAgent.install(); transformer = builder.installOn(ByteBuddyAgent.getInstrumentation()); - Logger logger = (Logger) LoggerFactory.getLogger(ExceptionLogger.class); - testAppender.setContext(logger.getLoggerContext()); - logger.addAppender(testAppender); - testAppender.start(); + Logger logger = Logger.getLogger(ExceptionLogger.class.getName()); + logger.setLevel(Level.FINE); + logger.addHandler(testHandler); } @AfterAll static void tearDown() { - testAppender.stop(); + testHandler.close(); + Logger.getLogger(ExceptionLogger.class.getName()).removeHandler(testHandler); + transformer.reset( ByteBuddyAgent.getInstrumentation(), AgentBuilder.RedefinitionStrategy.RETRANSFORMATION); } @Test void exceptionHandlerInvoked() { - int initLogEvents = testAppender.list.size(); + int initLogEvents = testHandler.getRecords().size(); // Triggers classload and instrumentation assertThat(SomeClass.isInstrumented()).isTrue(); - assertThat(testAppender.list) + assertThat(testHandler.getRecords()) .hasSize(initLogEvents + 1) .last() .satisfies( event -> { - assertThat(event.getLevel()).isEqualTo(Level.DEBUG); + assertThat(event.getLevel()).isEqualTo(Level.FINE); assertThat(event.getMessage()) .startsWith("Failed to handle exception in instrumentation for"); }); @@ -93,7 +91,7 @@ void exceptionHandlerInvoked() { @Test void exceptionOnNondelegatingClassloader() throws Exception { - int initLogEvents = testAppender.list.size(); + int initLogEvents = testHandler.getRecords().size(); URL[] classpath = new URL[] {SomeClass.class.getProtectionDomain().getCodeSource().getLocation()}; URLClassLoader loader = new URLClassLoader(classpath, null); @@ -104,7 +102,7 @@ void exceptionOnNondelegatingClassloader() throws Exception { Class someClazz = loader.loadClass(SomeClass.class.getName()); assertThat(someClazz.getClassLoader()).isSameAs(loader); someClazz.getMethod("isInstrumented").invoke(null); - assertThat(testAppender.list).hasSize(initLogEvents); + assertThat(testHandler.getRecords()).hasSize(initLogEvents); } @Test diff --git a/javaagent-tooling/src/testExceptionHandler/java/io/opentelemetry/javaagent/tooling/bytebuddy/TestHandler.java b/javaagent-tooling/src/testExceptionHandler/java/io/opentelemetry/javaagent/tooling/bytebuddy/TestHandler.java new file mode 100644 index 000000000000..3f28fc626e77 --- /dev/null +++ b/javaagent-tooling/src/testExceptionHandler/java/io/opentelemetry/javaagent/tooling/bytebuddy/TestHandler.java @@ -0,0 +1,32 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.tooling.bytebuddy; + +import java.util.ArrayList; +import java.util.List; +import java.util.logging.Handler; +import java.util.logging.LogRecord; + +final class TestHandler extends Handler { + private final List records = new ArrayList<>(); + + @Override + public void publish(LogRecord record) { + records.add(record); + } + + @Override + public void flush() {} + + @Override + public void close() { + records.clear(); + } + + List getRecords() { + return records; + } +} diff --git a/javaagent/build.gradle.kts b/javaagent/build.gradle.kts index 2fcd5d36fabe..3e74a9a5d801 100644 --- a/javaagent/build.gradle.kts +++ b/javaagent/build.gradle.kts @@ -50,7 +50,6 @@ dependencies { bootstrapLibs(project(":instrumentation-appender-api-internal")) bootstrapLibs(project(":javaagent-bootstrap")) bootstrapLibs(project(":javaagent-instrumentation-api")) - bootstrapLibs("org.slf4j:slf4j-simple") baseJavaagentLibs(project(":javaagent-extension-api")) baseJavaagentLibs(project(":javaagent-tooling")) diff --git a/muzzle/build.gradle.kts b/muzzle/build.gradle.kts index a25a867c76a5..400d94022be9 100644 --- a/muzzle/build.gradle.kts +++ b/muzzle/build.gradle.kts @@ -19,7 +19,6 @@ dependencies { implementation(project(":instrumentation-api")) implementation(project(":javaagent-instrumentation-api")) implementation(project(":javaagent-extension-api")) - implementation("org.slf4j:slf4j-api") // Used by byte-buddy but not brought in as a transitive dependency. compileOnly("com.google.code.findbugs:annotations") diff --git a/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/HelperInjector.java b/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/HelperInjector.java index e9c1154b08ec..0571f90b5c9f 100644 --- a/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/HelperInjector.java +++ b/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/HelperInjector.java @@ -5,6 +5,9 @@ package io.opentelemetry.javaagent.tooling; +import static java.util.logging.Level.FINE; +import static java.util.logging.Level.SEVERE; + import io.opentelemetry.instrumentation.api.cache.Cache; import io.opentelemetry.javaagent.bootstrap.HelperResources; import io.opentelemetry.javaagent.bootstrap.InjectedClassHelper; @@ -175,22 +178,27 @@ private void injectHelperResources(ClassLoader classLoader) { for (HelperResource helperResource : helperResources) { URL resource = helpersSource.getResource(helperResource.getAgentPath()); if (resource == null) { - logger.debug( - "Helper resource {} requested but not found.", helperResource.getAgentPath()); + logger.log( + FINE, + "Helper resource {0} requested but not found.", + helperResource.getAgentPath()); continue; } if (helperResource.allClassLoaders()) { - logger.debug( - "Injecting resource onto all classloaders: {}", + logger.log( + FINE, + "Injecting resource onto all classloaders: {0}", helperResource.getApplicationPath()); HelperResources.registerForAllClassLoaders( helperResource.getApplicationPath(), resource); } else { - logger.debug( - "Injecting resource onto classloader {} -> {}", - classLoader, - helperResource.getApplicationPath()); + if (logger.isLoggable(FINE)) { + logger.log( + FINE, + "Injecting resource onto classloader {0} -> {1}", + new Object[] {classLoader, helperResource.getApplicationPath()}); + } HelperResources.register(classLoader, helperResource.getApplicationPath(), resource); } } @@ -203,7 +211,8 @@ private void injectHelperClasses( TypeDescription typeDescription, ClassLoader classLoader, JavaModule module) { classLoader = maskNullClassLoader(classLoader); if (classLoader == BOOTSTRAP_CLASSLOADER_PLACEHOLDER && instrumentation == null) { - logger.error( + logger.log( + SEVERE, "Cannot inject helpers into bootstrap classloader without an instance of Instrumentation. Programmer error!"); return; } @@ -212,7 +221,12 @@ private void injectHelperClasses( classLoader, cl -> { try { - logger.debug("Injecting classes onto classloader {} -> {}", cl, helperClassNames); + if (logger.isLoggable(FINE)) { + logger.log( + FINE, + "Injecting classes onto classloader {0} -> {1}", + new Object[] {cl, helperClassNames}); + } Map classnameToBytes = getHelperMap(); Map map = @@ -233,12 +247,13 @@ private void injectHelperClasses( injectBootstrapClassLoader(classnameToBytes); } } catch (Exception e) { - logger.error( - "Error preparing helpers while processing {} for {}. Failed to inject helper classes into instance {}", - typeDescription, - requestingName, - cl, - e); + if (logger.isLoggable(SEVERE)) { + logger.log( + SEVERE, + "Error preparing helpers while processing {0} for {1}. Failed to inject helper classes into instance {2}", + new Object[] {typeDescription, requestingName, cl}, + e); + } throw new IllegalStateException(e); } return true; diff --git a/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/TransformSafeLogger.java b/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/TransformSafeLogger.java index f0ec5ec6932a..212e1abbefea 100644 --- a/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/TransformSafeLogger.java +++ b/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/TransformSafeLogger.java @@ -5,12 +5,12 @@ package io.opentelemetry.javaagent.tooling; +import java.text.MessageFormat; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; +import java.util.logging.Level; +import java.util.logging.Logger; import javax.annotation.Nullable; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import org.slf4j.event.Level; /** * Debug logging that is performed under class file transform needs to use this class, because @@ -42,147 +42,59 @@ public final class TransformSafeLogger { private final Logger logger; public static TransformSafeLogger getLogger(Class clazz) { - return new TransformSafeLogger(LoggerFactory.getLogger(clazz)); + return new TransformSafeLogger(Logger.getLogger(clazz.getName())); } private TransformSafeLogger(Logger logger) { this.logger = logger; } - public void debug(String format, Object arg) { - if (logMessageQueue != null) { - logMessageQueue.offer(new LogMessage(Level.DEBUG, logger, format, arg)); - } else { - logger.debug(format, arg); - } - } - - public void debug(String format, Object arg1, Object arg2) { - if (logMessageQueue != null) { - logMessageQueue.offer(new LogMessage(Level.DEBUG, logger, format, arg1, arg2)); - } else { - logger.debug(format, arg1, arg2); - } - } - - public void debug(String format, Object... arguments) { - if (logMessageQueue != null) { - logMessageQueue.offer(new LogMessage(Level.DEBUG, logger, format, arguments)); - } else { - logger.debug(format, arguments); - } - } - - public boolean isDebugEnabled() { - return logger.isDebugEnabled(); - } - - public void trace(String format, Object arg) { - if (logMessageQueue != null) { - logMessageQueue.offer(new LogMessage(Level.TRACE, logger, format, arg)); - } else { - logger.trace(format, arg); - } - } - - public void trace(String format, Object arg1, Object arg2) { - if (logMessageQueue != null) { - logMessageQueue.offer(new LogMessage(Level.TRACE, logger, format, arg1, arg2)); - } else { - logger.trace(format, arg1, arg2); - } - } - - public void trace(String format, Object... arguments) { - if (logMessageQueue != null) { - logMessageQueue.offer(new LogMessage(Level.TRACE, logger, format, arguments)); - } else { - logger.trace(format, arguments); - } - } - - public void warn(String format) { - if (logMessageQueue != null) { - logMessageQueue.offer(new LogMessage(Level.WARN, logger, format)); - } else { - logger.warn(format); - } - } - - public void warn(String format, Object arg) { - if (logMessageQueue != null) { - logMessageQueue.offer(new LogMessage(Level.WARN, logger, format, arg)); - } else { - logger.warn(format, arg); - } - } - - public void warn(String format, Object arg1, Object arg2) { - if (logMessageQueue != null) { - logMessageQueue.offer(new LogMessage(Level.WARN, logger, format, arg1, arg2)); - } else { - logger.warn(format, arg1, arg2); - } - } - - public void warn(String format, Object... arguments) { - if (logMessageQueue != null) { - logMessageQueue.offer(new LogMessage(Level.WARN, logger, format, arguments)); - } else { - logger.warn(format, arguments); - } + public boolean isLoggable(Level level) { + return logger.isLoggable(level); } - public void error(String format) { + public void log(Level level, String message) { if (logMessageQueue != null) { - logMessageQueue.offer(new LogMessage(Level.ERROR, logger, format)); + logMessageQueue.offer(new LogMessage(level, logger, message, null, null)); } else { - logger.error(format); + logger.log(level, message); } } - public void error(String format, Object arg) { + public void log(Level level, String message, Object arg) { if (logMessageQueue != null) { - logMessageQueue.offer(new LogMessage(Level.ERROR, logger, format, arg)); + logMessageQueue.offer(new LogMessage(level, logger, message, null, new Object[] {arg})); } else { - logger.error(format, arg); + logger.log(level, message, arg); } } - public void error(String format, Object arg1, Object arg2) { + public void log(Level level, String message, Object[] args) { if (logMessageQueue != null) { - logMessageQueue.offer(new LogMessage(Level.ERROR, logger, format, arg1, arg2)); + logMessageQueue.offer(new LogMessage(level, logger, message, null, args)); } else { - logger.error(format, arg1, arg2); + logger.log(level, message, args); } } - public void error(String format, Object... arguments) { + public void log(Level level, String message, Object[] args, Throwable error) { if (logMessageQueue != null) { - logMessageQueue.offer(new LogMessage(Level.ERROR, logger, format, arguments)); + logMessageQueue.offer(new LogMessage(level, logger, message, error, args)); } else { - logger.error(format, arguments); + logger.log(level, formatMessage(message, args), error); } } - public boolean isTraceEnabled() { - return logger.isTraceEnabled(); - } - private static class LogMessageQueueReader implements Runnable { @Override public void run() { try { while (true) { LogMessage logMessage = logMessageQueue.take(); - if (logMessage.level == Level.DEBUG) { - logMessage.logger.debug(logMessage.format, logMessage.arguments); - } else if (logMessage.level == Level.TRACE) { - logMessage.logger.trace(logMessage.format, logMessage.arguments); - } else { - logMessage.logger.warn( - "level {} not implemented yet in TransformSafeLogger", logMessage.level); - } + logMessage.logger.log( + logMessage.level, + formatMessage(logMessage.format, logMessage.arguments), + logMessage.error); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); @@ -194,13 +106,24 @@ private static class LogMessage { private final Level level; private final Logger logger; private final String format; + private final Throwable error; private final Object[] arguments; - private LogMessage(Level level, Logger logger, String format, Object... arguments) { + private LogMessage( + Level level, Logger logger, String format, Throwable error, Object[] arguments) { this.level = level; this.logger = logger; this.format = format; + this.error = error; this.arguments = arguments; } } + + private static String formatMessage(String format, Object[] arguments) { + if (arguments == null || arguments.length == 0) { + return format; + } else { + return MessageFormat.format(format, arguments); + } + } } diff --git a/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/muzzle/generation/MuzzleCodeGenerator.java b/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/muzzle/generation/MuzzleCodeGenerator.java index 5e9bff42a920..2d070d3192f8 100644 --- a/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/muzzle/generation/MuzzleCodeGenerator.java +++ b/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/muzzle/generation/MuzzleCodeGenerator.java @@ -5,6 +5,8 @@ package io.opentelemetry.javaagent.tooling.muzzle.generation; +import static java.util.logging.Level.INFO; + import io.opentelemetry.javaagent.extension.instrumentation.InstrumentationModule; import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation; import io.opentelemetry.javaagent.tooling.muzzle.HelperResource; @@ -22,6 +24,7 @@ import java.util.Collection; import java.util.List; import java.util.Set; +import java.util.logging.Logger; import java.util.regex.Matcher; import java.util.regex.Pattern; import net.bytebuddy.asm.AsmVisitorWrapper; @@ -36,8 +39,6 @@ import org.objectweb.asm.MethodVisitor; import org.objectweb.asm.Opcodes; import org.objectweb.asm.Type; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; /** * This class generates the actual implementation of the {@code @@ -48,7 +49,7 @@ *

This class is run at compile time by the {@link MuzzleCodeGenerationPlugin} ByteBuddy plugin. */ final class MuzzleCodeGenerator implements AsmVisitorWrapper { - private static final Logger logger = LoggerFactory.getLogger(MuzzleCodeGenerator.class); + private static final Logger logger = Logger.getLogger(MuzzleCodeGenerator.class.getName()); private static final String MUZZLE_REFERENCES_METHOD_NAME = "getMuzzleReferences"; private static final String MUZZLE_HELPER_CLASSES_METHOD_NAME = "getMuzzleHelperClassNames"; @@ -138,28 +139,28 @@ public MethodVisitor visitMethod( int access, String name, String descriptor, String signature, String[] exceptions) { if (MUZZLE_REFERENCES_METHOD_NAME.equals(name)) { generateReferencesMethod = false; - logger.info( - "The '{}' method was already found in class '{}'. Muzzle will not generate it again", - MUZZLE_REFERENCES_METHOD_NAME, - instrumentationClassName); + logMethodAlreadyExistsMessage(MUZZLE_REFERENCES_METHOD_NAME); } if (MUZZLE_HELPER_CLASSES_METHOD_NAME.equals(name)) { generateHelperClassNamesMethod = false; - logger.info( - "The '{}' method was already found in class '{}'. Muzzle will not generate it again", - MUZZLE_HELPER_CLASSES_METHOD_NAME, - instrumentationClassName); + logMethodAlreadyExistsMessage(MUZZLE_HELPER_CLASSES_METHOD_NAME); } if (MUZZLE_VIRTUAL_FIELDS_METHOD_NAME.equals(name)) { generateVirtualFieldsMethod = false; - logger.info( - "The '{}' method was already found in class '{}'. Muzzle will not generate it again", - MUZZLE_VIRTUAL_FIELDS_METHOD_NAME, - instrumentationClassName); + logMethodAlreadyExistsMessage(MUZZLE_VIRTUAL_FIELDS_METHOD_NAME); } return super.visitMethod(access, name, descriptor, signature, exceptions); } + private void logMethodAlreadyExistsMessage(String muzzleVirtualFieldsMethodName) { + if (logger.isLoggable(INFO)) { + logger.log( + INFO, + "The '{0}' method was already found in class '{1}'. Muzzle will not generate it again", + new Object[] {muzzleVirtualFieldsMethodName, instrumentationClassName}); + } + } + @Override public void visitEnd() { ReferenceCollector collector = collectReferences();