From d3df940137f82efbcc2b0b7f0215dbd6900c6a2b Mon Sep 17 00:00:00 2001 From: Lauri Tulmin Date: Tue, 15 Oct 2024 15:08:38 +0300 Subject: [PATCH] Set up virtual field transforms before otel sdk is initialized --- .../executors/javaagent/build.gradle.kts | 2 + .../ExecutorsInstrumentationModule.java | 6 +- .../executors/ThreadPoolExecutorTest.java | 7 ++ .../internal/reflection/ReflectionHelper.java | 18 ++-- .../bootstrap/VirtualFieldDetector.java | 34 ++++--- .../InstrumentationModule.java | 22 +++-- .../internal/EarlyInstrumentationModule.java | 23 +++++ .../javaagent/tooling/AgentInstaller.java | 90 +++++++++++++------ ...mplementationClassFileLocatorProvider.java | 57 ++++++++++++ ...ieldBackedImplementationConfiguration.java | 19 ++++ .../FieldBackedImplementationInstaller.java | 26 +++--- .../field/GeneratedVirtualFieldNames.java | 4 + .../InstrumentationLoader.java | 2 +- .../agent/builder/AgentBuilderUtil.java | 7 +- .../tooling/muzzle/AgentLocationStrategy.java | 8 +- .../tooling/muzzle/AgentTooling.java | 19 +++- .../muzzle/ClassFileLocatorProvider.java | 20 +++++ .../muzzle/AgentLocationStrategyTest.java | 2 +- 18 files changed, 292 insertions(+), 74 deletions(-) create mode 100644 javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/extension/instrumentation/internal/EarlyInstrumentationModule.java create mode 100644 javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/FieldBackedImplementationClassFileLocatorProvider.java create mode 100644 javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/FieldBackedImplementationConfiguration.java create mode 100644 muzzle/src/main/java/io/opentelemetry/javaagent/tooling/muzzle/ClassFileLocatorProvider.java diff --git a/instrumentation/executors/javaagent/build.gradle.kts b/instrumentation/executors/javaagent/build.gradle.kts index 65fd4332209a..5d15c4b6a5ff 100644 --- a/instrumentation/executors/javaagent/build.gradle.kts +++ b/instrumentation/executors/javaagent/build.gradle.kts @@ -15,6 +15,7 @@ dependencies { testImplementation(project(":instrumentation:executors:testing")) testImplementation("org.scala-lang:scala-library:2.11.12") testCompileOnly(project(":instrumentation:executors:bootstrap")) + testCompileOnly(project(":javaagent-bootstrap")) } testing { @@ -30,6 +31,7 @@ testing { dependencies { implementation(project(":instrumentation:executors:testing")) compileOnly(project(":instrumentation:executors:bootstrap")) + compileOnly(project(":javaagent-bootstrap")) } targets { diff --git a/instrumentation/executors/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/executors/ExecutorsInstrumentationModule.java b/instrumentation/executors/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/executors/ExecutorsInstrumentationModule.java index 60de54633025..b7e57eeee455 100644 --- a/instrumentation/executors/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/executors/ExecutorsInstrumentationModule.java +++ b/instrumentation/executors/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/executors/ExecutorsInstrumentationModule.java @@ -10,10 +10,12 @@ import com.google.auto.service.AutoService; import io.opentelemetry.javaagent.extension.instrumentation.InstrumentationModule; import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation; +import io.opentelemetry.javaagent.extension.instrumentation.internal.EarlyInstrumentationModule; import java.util.List; -@AutoService(InstrumentationModule.class) -public class ExecutorsInstrumentationModule extends InstrumentationModule { +@AutoService({InstrumentationModule.class, EarlyInstrumentationModule.class}) +public class ExecutorsInstrumentationModule extends InstrumentationModule + implements EarlyInstrumentationModule { public ExecutorsInstrumentationModule() { super("executors"); diff --git a/instrumentation/executors/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/executors/ThreadPoolExecutorTest.java b/instrumentation/executors/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/executors/ThreadPoolExecutorTest.java index e31d0d2d4fa0..010399cab3ce 100644 --- a/instrumentation/executors/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/executors/ThreadPoolExecutorTest.java +++ b/instrumentation/executors/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/executors/ThreadPoolExecutorTest.java @@ -10,7 +10,9 @@ import io.opentelemetry.api.baggage.Baggage; import io.opentelemetry.context.Scope; +import io.opentelemetry.javaagent.bootstrap.VirtualFieldInstalledMarker; import java.util.concurrent.CountDownLatch; +import java.util.concurrent.FutureTask; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; @@ -19,6 +21,11 @@ class ThreadPoolExecutorTest { + @Test + void virtualFieldsAdded() { + assertThat(VirtualFieldInstalledMarker.class).isAssignableFrom(FutureTask.class); + } + @Test void shouldPassOriginalRunnableToBeforeAfterMethods() throws InterruptedException { CountDownLatch latch = new CountDownLatch(1); diff --git a/instrumentation/internal/internal-reflection/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/internal/reflection/ReflectionHelper.java b/instrumentation/internal/internal-reflection/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/internal/reflection/ReflectionHelper.java index 33f947491483..241c731f1469 100644 --- a/instrumentation/internal/internal-reflection/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/internal/reflection/ReflectionHelper.java +++ b/instrumentation/internal/internal-reflection/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/internal/reflection/ReflectionHelper.java @@ -11,6 +11,8 @@ import java.lang.reflect.Field; import java.lang.reflect.Method; import java.util.ArrayList; +import java.util.Collection; +import java.util.HashSet; import java.util.List; public final class ReflectionHelper { @@ -61,21 +63,23 @@ public static Class[] filterInterfaces(Class[] interfaces, Class contai return interfaces; } List> result = new ArrayList<>(interfaces.length); + Collection virtualFieldClassNames = new HashSet<>(); boolean hasVirtualFieldMarker = false; for (Class interfaceClass : interfaces) { // filter out virtual field marker and accessor interfaces - if (interfaceClass == VirtualFieldInstalledMarker.class - || (VirtualFieldAccessorMarker.class.isAssignableFrom(interfaceClass) - && interfaceClass.isSynthetic() - && interfaceClass.getName().contains("VirtualFieldAccessor$"))) { - hasVirtualFieldMarker = true; + if (interfaceClass == VirtualFieldInstalledMarker.class) { + continue; + } else if (VirtualFieldAccessorMarker.class.isAssignableFrom(interfaceClass) + && interfaceClass.isSynthetic() + && interfaceClass.getName().contains("VirtualFieldAccessor$")) { + virtualFieldClassNames.add(interfaceClass.getName()); continue; } result.add(interfaceClass); } - if (hasVirtualFieldMarker) { - VirtualFieldDetector.markVirtualFieldsPresent(containingClass); + if (!virtualFieldClassNames.isEmpty()) { + VirtualFieldDetector.markVirtualFields(containingClass, virtualFieldClassNames); } return result.toArray(new Class[0]); diff --git a/javaagent-bootstrap/src/main/java/io/opentelemetry/javaagent/bootstrap/VirtualFieldDetector.java b/javaagent-bootstrap/src/main/java/io/opentelemetry/javaagent/bootstrap/VirtualFieldDetector.java index 80e14aab03f8..0a1664bdf034 100644 --- a/javaagent-bootstrap/src/main/java/io/opentelemetry/javaagent/bootstrap/VirtualFieldDetector.java +++ b/javaagent-bootstrap/src/main/java/io/opentelemetry/javaagent/bootstrap/VirtualFieldDetector.java @@ -6,36 +6,46 @@ package io.opentelemetry.javaagent.bootstrap; import io.opentelemetry.instrumentation.api.internal.cache.Cache; -import java.util.Arrays; +import java.util.Collection; /** Helper class for detecting whether given class has virtual fields. */ public final class VirtualFieldDetector { - private static final Cache, Boolean> classesWithVirtualFields = Cache.weak(); + // class to virtual field interface dot class names (see + // GeneratedVirtualFieldNames.getFieldAccessorInterfaceName) + private static final Cache, Collection> classesWithVirtualFields = Cache.weak(); private VirtualFieldDetector() {} /** - * Detect whether given class has virtual fields. This method looks for virtual fields only from - * the specified class not its super classes. + * Detect whether given class has given virtual field. This method looks for virtual fields only + * from the specified class not its super classes. * * @param clazz a class - * @return true if given class has virtual fields + * @param virtualFieldInterfaceClassName virtual field interface class dot name + * @return true if given class has the specified virtual field */ - public static boolean hasVirtualFields(Class clazz) { + public static boolean hasVirtualField(Class clazz, String virtualFieldInterfaceClassName) { + if (!VirtualFieldInstalledMarker.class.isAssignableFrom(clazz)) { + return false; + } // clazz.getInterfaces() needs to be called before reading from classesWithVirtualFields // as the call to clazz.getInterfaces() triggers adding clazz to that map via instrumentation - // calling VirtualFieldDetector#markVirtualFieldsPresent() from Class#getInterfaces() + // calling VirtualFieldDetector#markVirtualFields() from Class#getInterfaces() Class[] interfaces = clazz.getInterfaces(); // to avoid breaking in case internal-reflection instrumentation is disabled check whether // interfaces array contains virtual field marker interface - if (Arrays.asList(interfaces).contains(VirtualFieldInstalledMarker.class)) { - return true; + for (Class interfaceClass : interfaces) { + if (virtualFieldInterfaceClassName.equals(interfaceClass.getName())) { + return true; + } } - return classesWithVirtualFields.get(clazz) != null; + + Collection virtualFields = classesWithVirtualFields.get(clazz); + return virtualFields != null && virtualFields.contains(virtualFieldInterfaceClassName); } - public static void markVirtualFieldsPresent(Class clazz) { - classesWithVirtualFields.put(clazz, Boolean.TRUE); + public static void markVirtualFields(Class clazz, Collection virtualFieldClassName) { + classesWithVirtualFields.put(clazz, virtualFieldClassName); } } diff --git a/javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/extension/instrumentation/InstrumentationModule.java b/javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/extension/instrumentation/InstrumentationModule.java index 7f404090b679..e6ee634fe5d9 100644 --- a/javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/extension/instrumentation/InstrumentationModule.java +++ b/javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/extension/instrumentation/InstrumentationModule.java @@ -33,14 +33,6 @@ */ public abstract class InstrumentationModule implements Ordered { private static final Logger logger = Logger.getLogger(InstrumentationModule.class.getName()); - private static final boolean indyEnabled; - - static { - indyEnabled = ExperimentalConfig.get().indyEnabled(); - if (indyEnabled) { - logger.info("Enabled indy for instrumentation modules"); - } - } private final Set instrumentationNames; @@ -125,7 +117,7 @@ public boolean isHelperClass(String className) { * techniques. The non-inlining of advice will be enforced by muzzle (TODO) */ public boolean isIndyModule() { - return indyEnabled; + return IndyConfigurationHolder.indyEnabled; } /** Register resource names to inject into the user's class loader. */ @@ -163,4 +155,16 @@ public ElementMatcher.Junction classLoaderMatcher() { public List getAdditionalHelperClassNames() { return Collections.emptyList(); } + + // InstrumentationModule is loaded before ExperimentalConfig is initialized + private static class IndyConfigurationHolder { + private static final boolean indyEnabled; + + static { + indyEnabled = ExperimentalConfig.get().indyEnabled(); + if (indyEnabled) { + logger.info("Enabled indy for instrumentation modules"); + } + } + } } diff --git a/javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/extension/instrumentation/internal/EarlyInstrumentationModule.java b/javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/extension/instrumentation/internal/EarlyInstrumentationModule.java new file mode 100644 index 000000000000..b7da6f55cfe9 --- /dev/null +++ b/javaagent-extension-api/src/main/java/io/opentelemetry/javaagent/extension/instrumentation/internal/EarlyInstrumentationModule.java @@ -0,0 +1,23 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.extension.instrumentation.internal; + +import io.opentelemetry.javaagent.extension.instrumentation.InstrumentationModule; +import io.opentelemetry.sdk.autoconfigure.spi.Ordered; + +/** + * Marker interface for instrumentation modules whose virtual fields should be set up before + * OpenTelemetry SDK is initialized. + * + *

This class is internal and is hence not for public use. Its APIs are unstable and can change + * at any time. + */ +public interface EarlyInstrumentationModule extends Ordered { + + default InstrumentationModule getInstrumentationModule() { + return (InstrumentationModule) this; + } +} 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 54c6938c96d9..e9d42a6d9a15 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 @@ -13,6 +13,7 @@ import static java.util.logging.Level.FINE; import static java.util.logging.Level.SEVERE; import static net.bytebuddy.matcher.ElementMatchers.any; +import static net.bytebuddy.matcher.ElementMatchers.none; import io.opentelemetry.context.Context; import io.opentelemetry.context.ContextStorage; @@ -30,11 +31,15 @@ import io.opentelemetry.javaagent.bootstrap.internal.ConfiguredResourceAttributesHolder; import io.opentelemetry.javaagent.extension.AgentListener; import io.opentelemetry.javaagent.extension.ignore.IgnoredTypesConfigurer; +import io.opentelemetry.javaagent.extension.instrumentation.internal.EarlyInstrumentationModule; import io.opentelemetry.javaagent.tooling.asyncannotationsupport.WeakRefAsyncOperationEndStrategies; import io.opentelemetry.javaagent.tooling.bootstrap.BootstrapPackagesBuilderImpl; import io.opentelemetry.javaagent.tooling.bootstrap.BootstrapPackagesConfigurer; import io.opentelemetry.javaagent.tooling.config.ConfigPropertiesBridge; import io.opentelemetry.javaagent.tooling.config.EarlyInitAgentConfig; +import io.opentelemetry.javaagent.tooling.field.FieldBackedImplementationConfiguration; +import io.opentelemetry.javaagent.tooling.field.VirtualFieldImplementationInstaller; +import io.opentelemetry.javaagent.tooling.field.VirtualFieldImplementationInstallerFactory; import io.opentelemetry.javaagent.tooling.ignore.IgnoredClassLoadersMatcher; import io.opentelemetry.javaagent.tooling.ignore.IgnoredTypesBuilderImpl; import io.opentelemetry.javaagent.tooling.ignore.IgnoredTypesMatcher; @@ -50,6 +55,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.logging.LogManager; import java.util.logging.Logger; import java.util.stream.Stream; @@ -85,6 +91,8 @@ public class AgentInstaller { private static final Map> CLASS_LOAD_CALLBACKS = new HashMap<>(); + private static volatile boolean instrumentationInstalled; + public static void installBytebuddyAgent( Instrumentation inst, ClassLoader extensionClassLoader, EarlyInitAgentConfig earlyConfig) { addByteBuddyRawSetting(); @@ -99,7 +107,7 @@ public static void installBytebuddyAgent( if (earlyConfig.getBoolean(JAVAAGENT_ENABLED_CONFIG, true)) { setupUnsafe(inst); List agentListeners = loadOrdered(AgentListener.class, extensionClassLoader); - installBytebuddyAgent(inst, extensionClassLoader, agentListeners); + installBytebuddyAgent(inst, extensionClassLoader, agentListeners, earlyConfig); } else { logger.fine("Tracing is disabled, not installing instrumentations."); } @@ -108,31 +116,13 @@ public static void installBytebuddyAgent( private static void installBytebuddyAgent( Instrumentation inst, ClassLoader extensionClassLoader, - Iterable agentListeners) { + Iterable agentListeners, + EarlyInitAgentConfig earlyConfig) { WeakRefAsyncOperationEndStrategies.initialize(); - EmbeddedInstrumentationProperties.setPropertiesLoader(extensionClassLoader); - setDefineClassHandler(); - - // If noop OpenTelemetry is enabled, autoConfiguredSdk will be null and AgentListeners are not - // called - AutoConfiguredOpenTelemetrySdk autoConfiguredSdk = - installOpenTelemetrySdk(extensionClassLoader); - - ConfigProperties sdkConfig = AutoConfigureUtil.getConfig(autoConfiguredSdk); - AgentInstrumentationConfig.internalInitializeConfig(new ConfigPropertiesBridge(sdkConfig)); - copyNecessaryConfigToSystemProperties(sdkConfig); - - setBootstrapPackages(sdkConfig, extensionClassLoader); - ConfiguredResourceAttributesHolder.initialize( - SdkAutoconfigureAccess.getResourceAttributes(autoConfiguredSdk)); - - for (BeforeAgentListener agentListener : - loadOrdered(BeforeAgentListener.class, extensionClassLoader)) { - agentListener.beforeAgent(autoConfiguredSdk); - } + FieldBackedImplementationConfiguration.configure(earlyConfig); AgentBuilder agentBuilder = new AgentBuilder.Default( @@ -154,9 +144,6 @@ private static void installBytebuddyAgent( if (JavaModule.isSupported()) { agentBuilder = agentBuilder.with(new ExposeAgentBootstrapListener(inst)); } - - agentBuilder = configureIgnoredTypes(sdkConfig, extensionClassLoader, agentBuilder); - if (logger.isLoggable(FINE)) { agentBuilder = agentBuilder @@ -166,6 +153,28 @@ private static void installBytebuddyAgent( .with(new TransformLoggingListener()); } + installEarlyInstrumentation(agentBuilder, inst); + + // If noop OpenTelemetry is enabled, autoConfiguredSdk will be null and AgentListeners are not + // called + AutoConfiguredOpenTelemetrySdk autoConfiguredSdk = + installOpenTelemetrySdk(extensionClassLoader); + + ConfigProperties sdkConfig = AutoConfigureUtil.getConfig(autoConfiguredSdk); + AgentInstrumentationConfig.internalInitializeConfig(new ConfigPropertiesBridge(sdkConfig)); + copyNecessaryConfigToSystemProperties(sdkConfig); + + setBootstrapPackages(sdkConfig, extensionClassLoader); + ConfiguredResourceAttributesHolder.initialize( + SdkAutoconfigureAccess.getResourceAttributes(autoConfiguredSdk)); + + for (BeforeAgentListener agentListener : + loadOrdered(BeforeAgentListener.class, extensionClassLoader)) { + agentListener.beforeAgent(autoConfiguredSdk); + } + + agentBuilder = configureIgnoredTypes(sdkConfig, extensionClassLoader, agentBuilder); + int numberOfLoadedExtensions = 0; for (AgentExtension agentExtension : loadOrdered(AgentExtension.class, extensionClassLoader)) { if (logger.isLoggable(FINE)) { @@ -192,6 +201,7 @@ private static void installBytebuddyAgent( agentBuilder = AgentBuilderUtil.optimize(agentBuilder); ResettableClassFileTransformer resettableClassFileTransformer = agentBuilder.installOn(inst); + instrumentationInstalled = true; ClassFileTransformerHolder.setClassFileTransformer(resettableClassFileTransformer); addHttpServerResponseCustomizers(extensionClassLoader); @@ -199,6 +209,36 @@ private static void installBytebuddyAgent( runAfterAgentListeners(agentListeners, autoConfiguredSdk); } + private static void installEarlyInstrumentation( + AgentBuilder agentBuilder, Instrumentation instrumentation) { + // We are only going to install the virtual fields here. Installing virtual field changes class + // structure and can not be applied to already loaded classes. + agentBuilder = agentBuilder.with(AgentBuilder.RedefinitionStrategy.DISABLED); + + AgentBuilder.Identified.Extendable extendableAgentBuilder = + agentBuilder + .ignore( + target -> instrumentationInstalled, // turn off after instrumentation is installed + Objects::nonNull) + .type(none()) + .transform( + (builder, typeDescription, classLoader, module, protectionDomain) -> builder); + + VirtualFieldImplementationInstallerFactory virtualFieldInstallerFactory = + new VirtualFieldImplementationInstallerFactory(); + for (EarlyInstrumentationModule earlyInstrumentationModule : + loadOrdered(EarlyInstrumentationModule.class, Utils.getExtensionsClassLoader())) { + + VirtualFieldImplementationInstaller contextProvider = + virtualFieldInstallerFactory.create( + earlyInstrumentationModule.getInstrumentationModule()); + extendableAgentBuilder = contextProvider.injectFields(extendableAgentBuilder); + } + + agentBuilder = AgentBuilderUtil.optimize(extendableAgentBuilder); + agentBuilder.installOn(instrumentation); + } + private static void copyNecessaryConfigToSystemProperties(ConfigProperties config) { for (String property : asList("otel.instrumentation.experimental.span-suppression-strategy")) { String value = config.getString(property); diff --git a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/FieldBackedImplementationClassFileLocatorProvider.java b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/FieldBackedImplementationClassFileLocatorProvider.java new file mode 100644 index 000000000000..f857d0376fa0 --- /dev/null +++ b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/FieldBackedImplementationClassFileLocatorProvider.java @@ -0,0 +1,57 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.tooling.field; + +import com.google.auto.service.AutoService; +import io.opentelemetry.javaagent.bootstrap.VirtualFieldAccessorMarker; +import io.opentelemetry.javaagent.tooling.muzzle.ClassFileLocatorProvider; +import net.bytebuddy.ByteBuddy; +import net.bytebuddy.description.modifier.SyntheticState; +import net.bytebuddy.dynamic.ClassFileLocator; +import net.bytebuddy.dynamic.DynamicType; +import org.jetbrains.annotations.Nullable; + +@AutoService(ClassFileLocatorProvider.class) +public final class FieldBackedImplementationClassFileLocatorProvider + implements ClassFileLocatorProvider { + + @Nullable + @Override + public ClassFileLocator getClassFileLocator() { + if (!FieldBackedImplementationConfiguration.fieldInjectionEnabled) { + return null; + } + + return new VirtualFieldInterfaceLocator(); + } + + private static class VirtualFieldInterfaceLocator implements ClassFileLocator { + private static final ByteBuddy byteBuddy = new ByteBuddy(); + + private static DynamicType.Unloaded makeFieldAccessorInterface(String name) { + // create trimmed down version of the interface + return byteBuddy + .makeInterface() + .merge(SyntheticState.SYNTHETIC) + .name(name) + .implement(VirtualFieldAccessorMarker.class) + .make(); + } + + @Override + public Resolution locate(String name) { + if (GeneratedVirtualFieldNames.isVirtualFieldInterfaceName(name)) { + try (DynamicType.Unloaded type = makeFieldAccessorInterface(name)) { + return new Resolution.Explicit(type.getBytes()); + } + } + return new Resolution.Illegal(name); + } + + @Override + public void close() {} + } +} diff --git a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/FieldBackedImplementationConfiguration.java b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/FieldBackedImplementationConfiguration.java new file mode 100644 index 000000000000..370ca2e85662 --- /dev/null +++ b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/FieldBackedImplementationConfiguration.java @@ -0,0 +1,19 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.tooling.field; + +import io.opentelemetry.javaagent.tooling.config.EarlyInitAgentConfig; + +public final class FieldBackedImplementationConfiguration { + static boolean fieldInjectionEnabled = true; + + public static void configure(EarlyInitAgentConfig config) { + fieldInjectionEnabled = + config.getBoolean("otel.javaagent.experimental.field-injection.enabled", true); + } + + private FieldBackedImplementationConfiguration() {} +} 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 5c1e69063fd3..bce86a829911 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,8 @@ package io.opentelemetry.javaagent.tooling.field; import static io.opentelemetry.javaagent.extension.matcher.AgentElementMatchers.hasSuperType; +import static io.opentelemetry.javaagent.tooling.field.FieldBackedImplementationConfiguration.fieldInjectionEnabled; +import static io.opentelemetry.javaagent.tooling.field.GeneratedVirtualFieldNames.getFieldAccessorInterfaceName; import static java.util.logging.Level.FINEST; import static net.bytebuddy.matcher.ElementMatchers.isAbstract; import static net.bytebuddy.matcher.ElementMatchers.named; @@ -14,7 +16,6 @@ import com.google.errorprone.annotations.CanIgnoreReturnValue; import io.opentelemetry.javaagent.bootstrap.InstrumentationHolder; import io.opentelemetry.javaagent.bootstrap.VirtualFieldDetector; -import io.opentelemetry.javaagent.bootstrap.internal.AgentInstrumentationConfig; import io.opentelemetry.javaagent.tooling.HelperInjector; import io.opentelemetry.javaagent.tooling.TransformSafeLogger; import io.opentelemetry.javaagent.tooling.instrumentation.InstrumentationModuleInstaller; @@ -63,10 +64,6 @@ final class FieldBackedImplementationInstaller implements VirtualFieldImplementa private static final TransformSafeLogger logger = TransformSafeLogger.getLogger(FieldBackedImplementationInstaller.class); - private static final boolean FIELD_INJECTION_ENABLED = - AgentInstrumentationConfig.get() - .getBoolean("otel.javaagent.experimental.field-injection.enabled", true); - private final Class instrumenterClass; private final VirtualFieldMappings virtualFieldMappings; @@ -173,14 +170,13 @@ Set of pairs (type name, field type name) for which we have matchers installed. We use this to make sure we do not install matchers repeatedly for cases when same context class is used by multiple instrumentations. */ - private static final Set> INSTALLED_VIRTUAL_FIELD_MATCHERS = - new HashSet<>(); + private final Set> installedVirtualFieldMatchers = new HashSet<>(); @Override public AgentBuilder.Identified.Extendable injectFields( AgentBuilder.Identified.Extendable builder) { - if (FIELD_INJECTION_ENABLED) { + if (fieldInjectionEnabled) { for (Map.Entry entry : virtualFieldMappings.entrySet()) { /* * For each virtual field defined in a current instrumentation we create an agent builder @@ -189,8 +185,8 @@ public AgentBuilder.Identified.Extendable injectFields( * since this is done when agent builder is being made, it doesn't affect actual * class transformation. */ - synchronized (INSTALLED_VIRTUAL_FIELD_MATCHERS) { - if (INSTALLED_VIRTUAL_FIELD_MATCHERS.contains(entry)) { + synchronized (installedVirtualFieldMatchers) { + if (installedVirtualFieldMatchers.contains(entry)) { if (logger.isLoggable(FINEST)) { logger.log( FINEST, @@ -206,7 +202,7 @@ public AgentBuilder.Identified.Extendable injectFields( "Making builder for {0} {1}", new Object[] {instrumenterClass.getName(), entry}); } - INSTALLED_VIRTUAL_FIELD_MATCHERS.add(entry); + installedVirtualFieldMatchers.add(entry); /* * For each virtual field defined in a current instrumentation we create an agent builder @@ -221,7 +217,7 @@ public AgentBuilder.Identified.Extendable injectFields( builder = builder .type(typeMatcher) - .and(safeToInjectFieldsMatcher()) + .and(safeToInjectFieldMatcher(entry.getKey(), entry.getValue())) .and(InstrumentationModuleInstaller.NOT_DECORATOR_MATCHER) .transform(NoOpTransformer.INSTANCE); @@ -243,7 +239,8 @@ public AgentBuilder.Identified.Extendable injectFields( return builder; } - private static AgentBuilder.RawMatcher safeToInjectFieldsMatcher() { + private static AgentBuilder.RawMatcher safeToInjectFieldMatcher( + String typeName, String fieldTypeName) { return (typeDescription, classLoader, module, classBeingRedefined, protectionDomain) -> { /* * The idea here is that we can add fields if class is just being loaded @@ -251,7 +248,8 @@ private static AgentBuilder.RawMatcher safeToInjectFieldsMatcher() { * fields before is being transformed again. */ return classBeingRedefined == null - || VirtualFieldDetector.hasVirtualFields(classBeingRedefined); + || VirtualFieldDetector.hasVirtualField( + classBeingRedefined, getFieldAccessorInterfaceName(typeName, fieldTypeName)); }; } diff --git a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/GeneratedVirtualFieldNames.java b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/GeneratedVirtualFieldNames.java index d1a797785a34..7c3ac6ffb807 100644 --- a/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/GeneratedVirtualFieldNames.java +++ b/javaagent-tooling/src/main/java/io/opentelemetry/javaagent/tooling/field/GeneratedVirtualFieldNames.java @@ -17,6 +17,10 @@ final class GeneratedVirtualFieldNames { private GeneratedVirtualFieldNames() {} + public static boolean isVirtualFieldInterfaceName(String className) { + return className.startsWith(DYNAMIC_CLASSES_PACKAGE + "VirtualFieldAccessor$"); + } + static String getVirtualFieldImplementationClassName(String typeName, String fieldTypeName) { return DYNAMIC_CLASSES_PACKAGE + "VirtualFieldImpl$" 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 e99286911745..71d6faf68679 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 @@ -54,7 +54,7 @@ public AgentBuilder extend(AgentBuilder agentBuilder, ConfigProperties config) { e); } } - logger.log(FINE, "Installed {0} instrumenter(s)", numberOfLoadedModules); + logger.log(FINE, "Installed {0} instrumentation(s)", numberOfLoadedModules); return agentBuilder; } diff --git a/javaagent-tooling/src/main/java/net/bytebuddy/agent/builder/AgentBuilderUtil.java b/javaagent-tooling/src/main/java/net/bytebuddy/agent/builder/AgentBuilderUtil.java index d596dc81ecf3..38f69bc50131 100644 --- a/javaagent-tooling/src/main/java/net/bytebuddy/agent/builder/AgentBuilderUtil.java +++ b/javaagent-tooling/src/main/java/net/bytebuddy/agent/builder/AgentBuilderUtil.java @@ -21,6 +21,7 @@ import java.util.logging.Logger; import javax.annotation.Nullable; import net.bytebuddy.agent.builder.AgentBuilder.Default.Transformation; +import net.bytebuddy.matcher.BooleanMatcher; import net.bytebuddy.matcher.ElementMatcher; import net.bytebuddy.matcher.ErasureMatcher; import net.bytebuddy.matcher.HasSuperClassMatcher; @@ -144,7 +145,7 @@ private static Result inspect(AgentBuilder.RawMatcher matcher) throws Exception ElementMatcher elementMatcher = getDelegateMatcher((AgentBuilder.RawMatcher.ForElementMatchers) matcher); Result result = inspect(elementMatcher); - if (result == null && logger.isLoggable(FINE)) { + if (result == null && logger.isLoggable(FINE) && shouldLog(elementMatcher)) { logger.log(Level.FINE, "Could not decompose matcher {0}", elementMatcher); } return result; @@ -309,6 +310,10 @@ private static Field getField(Class clazz, String name) { } } + private static boolean shouldLog(ElementMatcher elementMatcher) { + return !(elementMatcher instanceof BooleanMatcher); + } + private static class TransformContext extends AgentBuilder.Listener.Adapter { private static final ThreadLocal transformedName = new ThreadLocal<>(); diff --git a/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/muzzle/AgentLocationStrategy.java b/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/muzzle/AgentLocationStrategy.java index e69cc284499f..1a6476075878 100644 --- a/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/muzzle/AgentLocationStrategy.java +++ b/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/muzzle/AgentLocationStrategy.java @@ -19,9 +19,12 @@ public class AgentLocationStrategy implements AgentBuilder.LocationStrategy { private final ClassLoader bootstrapProxy; + private final List additionalLocators; - public AgentLocationStrategy(ClassLoader bootstrapProxy) { + public AgentLocationStrategy( + ClassLoader bootstrapProxy, List additionalLocators) { this.bootstrapProxy = bootstrapProxy; + this.additionalLocators = additionalLocators; } public ClassFileLocator classFileLocator(ClassLoader classLoader) { @@ -32,6 +35,9 @@ public ClassFileLocator classFileLocator(ClassLoader classLoader) { public ClassFileLocator classFileLocator(ClassLoader classLoader, JavaModule javaModule) { List locators = new ArrayList<>(); + if (additionalLocators != null) { + locators.addAll(additionalLocators); + } if (classLoader != null) { locators.add(ClassFileLocator.ForClassLoader.WeaklyReferenced.of(classLoader)); } diff --git a/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/muzzle/AgentTooling.java b/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/muzzle/AgentTooling.java index ea784ba7a0f2..d5c2f204cd16 100644 --- a/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/muzzle/AgentTooling.java +++ b/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/muzzle/AgentTooling.java @@ -5,9 +5,12 @@ package io.opentelemetry.javaagent.tooling.muzzle; +import java.util.ArrayList; import java.util.Iterator; +import java.util.List; import java.util.ServiceLoader; import net.bytebuddy.agent.builder.AgentBuilder; +import net.bytebuddy.dynamic.ClassFileLocator; import net.bytebuddy.utility.JavaModule; /** @@ -18,7 +21,7 @@ public final class AgentTooling { private static final AgentLocationStrategy LOCATION_STRATEGY = - new AgentLocationStrategy(getBootstrapProxy()); + new AgentLocationStrategy(getBootstrapProxy(), getLocators()); private static final AgentBuilder.PoolStrategy POOL_STRATEGY = new AgentCachingPoolStrategy(LOCATION_STRATEGY); @@ -49,6 +52,20 @@ private static ClassLoader getBootstrapProxy() { return null; } + private static List getLocators() { + List locators = new ArrayList<>(); + ServiceLoader.load(ClassFileLocatorProvider.class, AgentTooling.class.getClassLoader()) + .forEach( + provider -> { + ClassFileLocator locator = provider.getClassFileLocator(); + if (locator != null) { + locators.add(locator); + } + }); + + return locators; + } + public static boolean isTransforming(ClassLoader classLoader, String className) { CurrentTransform currentTransform = CURRENT_TRANSFORM.get(); if (currentTransform == null) { diff --git a/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/muzzle/ClassFileLocatorProvider.java b/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/muzzle/ClassFileLocatorProvider.java new file mode 100644 index 000000000000..7a501fac2eb6 --- /dev/null +++ b/muzzle/src/main/java/io/opentelemetry/javaagent/tooling/muzzle/ClassFileLocatorProvider.java @@ -0,0 +1,20 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.tooling.muzzle; + +import javax.annotation.Nullable; +import net.bytebuddy.dynamic.ClassFileLocator; + +/** + * This SPI can be used to add additional {@link ClassFileLocator}s to {@link + * AgentLocationStrategy}. + */ +public interface ClassFileLocatorProvider { + + /** Provide a class loader which can be used to look up bootstrap resources. */ + @Nullable + ClassFileLocator getClassFileLocator(); +} diff --git a/muzzle/src/test/java/io/opentelemetry/javaagent/tooling/muzzle/AgentLocationStrategyTest.java b/muzzle/src/test/java/io/opentelemetry/javaagent/tooling/muzzle/AgentLocationStrategyTest.java index 85c5b65ee7e1..c2cfcd1b41d2 100644 --- a/muzzle/src/test/java/io/opentelemetry/javaagent/tooling/muzzle/AgentLocationStrategyTest.java +++ b/muzzle/src/test/java/io/opentelemetry/javaagent/tooling/muzzle/AgentLocationStrategyTest.java @@ -35,7 +35,7 @@ void cleanup() { @Test void findsResourcesFromParentClassloader() throws Exception { ClassFileLocator locator = - new AgentLocationStrategy(ClassLoader.getSystemClassLoader()) + new AgentLocationStrategy(ClassLoader.getSystemClassLoader(), null) .classFileLocator(childLoader, null); assertThat(locator.locate("java/lang/Object").isResolved()).isTrue(); assertThat(lastLookup).hasValue("java/lang/Object.class");