Use "class loader" instead of "classloader" consistently in docs and comments (open-telemetry#6236)

* Use "class loader" consistently instead of classloader

* Java comments too

* Fix bad merge

Author: trask

docs/agent-features.md

@@ -16,10 +16,10 @@ provides.
   - Ability to disable individual instrumentation, or only enable certain ones.
 - Ability to load a custom exporter via an external JAR library
 - Isolation from application
-  - Separate Agent classloader with almost all agent-specific classes
-    - OpenTelemetry SDK initialized in Agent classloader
+  - Separate Agent class loader with almost all agent-specific classes
+    - OpenTelemetry SDK initialized in Agent class loader
   - Shading of instrumentation libraries when used in agent
-  - API bridge for application usage of API to access the Agent classloader's SDK
+  - API bridge for application usage of API to access the Agent class loader's SDK
     - API bridge not applied if user brings incompatible API version, preventing linkage errors (similar to safety mechanism below)
 - [Safety mechanisms](./safety-mechanisms.md) to prevent application linkage errors
   - Collect all references from instrumentation to library and only apply instrumentation if they exist in application

docs/contributing/classloader-hierarchy.svg docs/contributing/class-loader-hierarchy.svg

@@ -14,8 +14,8 @@ The only class that is loaded by the system class loader is the
 `io.opentelemetry.javaagent.OpenTelemetryAgent` class. This is the main class of the javaagent, it
 implements the
 [Java instrumentation agent specification](https://docs.oracle.com/javase/8/docs/api/java/lang/instrument/package-summary.html).
-This class is loaded during application startup by the system classloader. Its sole
-responsibility is to push the agent's classes into JVM's bootstrap classloader and immediately
+This class is loaded during application startup by the system class loader. Its sole
+responsibility is to push the agent's classes into JVM's bootstrap class loader and immediately
 delegate to the `io.opentelemetry.javaagent.bootstrap.AgentInitializer` class, living in the
 bootstrap class loader.
 
@@ -62,7 +62,7 @@ versions of some of our APIs (`opentelemetry-api`, `instrumentation-api`).
 
 ## Agent class loader
 
-The agent classloader contains almost everything else not mentioned before, including:
+The agent class loader contains almost everything else not mentioned before, including:
 
 * **The `javaagent-tooling` module**:
   this module picks up the initialization process started by `OpenTelemetryAgent`
@@ -108,5 +108,5 @@ the javaagent will apply shading dynamically in the runtime, when the extension
 
 ## Class loader hierarchy graph
 
-![Agent classloader hierarchy](classloader-hierarchy.svg)
+![Agent class loader hierarchy](class-loader-hierarchy.svg)
 [Image source](https://docs.google.com/drawings/d/1DOftemu_96_0RggzOV3hFXejqeZWTmPBgbkaUhHw--g)

docs/contributing/javaagent-structure.md

@@ -31,7 +31,7 @@ encounters a reference to a non-instrumentation class (determined by `Instrument
 and the `InstrumentationModule#isHelperClass(String)` predicate). Aside from references, the
 collection process also builds a graph of dependencies between internal instrumentation helper
 classes - this dependency graph is later used to construct a list of helper classes that will be
-injected to the application classloader (`InstrumentationModuleMuzzle#getMuzzleHelperClassNames()`).
+injected to the application class loader (`InstrumentationModuleMuzzle#getMuzzleHelperClassNames()`).
 Muzzle also automatically generates the `InstrumentationModuleMuzzle#registerMuzzleVirtualFields()`
 method. All collected references are then used to generate
 an `InstrumentationModuleMuzzle#getMuzzleReferences` method.
@@ -53,7 +53,7 @@ actual application classpath types the whole instrumentation is discarded.
 
 It is worth noting that because the muzzle check is expensive, it is only performed after a match
 has been made by the `InstrumentationModule#classLoaderMatcher()` and `TypeInstrumentation#typeMatcher()`
-matchers. The result of muzzle matcher is cached per classloader, so that it is only executed
+matchers. The result of muzzle matcher is cached per class loader, so that it is only executed
 once for the whole instrumentation module.
 
 The source code of the runtime muzzle matcher is located in the `muzzle` module.

docs/contributing/muzzle.md

@@ -13,7 +13,7 @@ explanations of how to use a particular method and why it works the way it does.
 
 An `InstrumentationModule` describes a set of individual `TypeInstrumentation` that need to be
 applied together to correctly instrument a specific library. Type instrumentations grouped in a
-module share helper classes, [muzzle runtime checks](muzzle.md), and applicable classloader criteria,
+module share helper classes, [muzzle runtime checks](muzzle.md), and applicable class loader criteria,
 and can only be enabled or disabled as a set.
 
 The OpenTelemetry javaagent finds all modules by using Java's `ServiceLoader` API. To make your
@@ -88,14 +88,14 @@ public List<String> helperResourceNames() {
 
 All classes referenced by service providers defined in the `helperResourceNames()` method are treated
 as helper classes: they're checked for invalid references and automatically injected into the
-application classloader.
+application class loader.
 
 ### Inject additional instrumentation helper classes manually with the `getAdditionalHelperClassNames()` method
 
 If you don't use the [muzzle gradle plugins](muzzle.md), or are in a scenario that requires
 providing the helper classes manually (for example, an unusual SPI implementation), you can
 override the `getAdditionalHelperClassNames()` method to provide a list of additional helper
-classes to be injected into the application classloader when the instrumentation is applied:
+classes to be injected into the application class loader when the instrumentation is applied:
 
 ```java
 public List<String> getAdditionalHelperClassNames() {
@@ -108,7 +108,7 @@ public List<String> getAdditionalHelperClassNames() {
 The order of the class names returned by this method matters: if you have several helper classes
 extending one another, you'll want to return the base class first. For example, if you have a
 `B extends A` class, the list should contain `A` first and `B` second. The helper classes are
-injected into the application classloader after those provided by the muzzle codegen plugin.
+injected into the application class loader after those provided by the muzzle codegen plugin.
 
 ### Restrict the criteria for applying the instrumentation by extending the `classLoaderMatcher()` method
 

docs/contributing/writing-instrumentation-module.md

@@ -385,7 +385,7 @@ here, including the instrumented library - you can only use JDK and OpenTelemetr
 ## Writing Java agent unit tests
 
 As mentioned before, tests in the `javaagent` module cannot access the javaagent instrumentation
-classes directly because of classloader separation - the javaagent classes are hidden and not
+classes directly because of class loader separation - the javaagent classes are hidden and not
 accessible from the instrumented application code.
 
 Ideally javaagent instrumentation is just a thin wrapper over library instrumentation, and so there

docs/contributing/writing-instrumentation.md

@@ -51,25 +51,25 @@ potentially cause linkage errors.
 
 ## Classloader separation
 
-See more detail about the classloader separation [here](./contributing/javaagent-structure.md).
+See more detail about the class loader separation [here](./contributing/javaagent-structure.md).
 
-The Java agent makes sure to include as little code as possible in the user app's classloader, and
+The Java agent makes sure to include as little code as possible in the user app's class loader, and
 all code that is included is either unique to the agent itself or shaded in the agent build. This is
 because if the agent included classes that are also used by the user's app and there was a version
 mismatch, it could cause linkage crashes.
 
-Instead of executing code in the app's classloader, the agent has its own agent classloader where
+Instead of executing code in the app's class loader, the agent has its own agent class loader where
 instrumentation is loaded and exporters and the SDK is configured. Only when applying an
 instrumentation (which will have passed Muzzle runtime checks) do we inject any additional classes
-that are needed by the instrumentation into the user's classloader. These classes are always either
+that are needed by the instrumentation into the user's class loader. These classes are always either
 unique to the agent or shaded versions of public libraries such as our library instrumentation
 modules and cannot cause version conflicts.
 
-To ensure agent classes are not automatically loaded into the user's classloader, possibly by an
+To ensure agent classes are not automatically loaded into the user's class loader, possibly by an
 eager loading application server, they are hidden in the agent JAR as standard, non-Java files.
 All packages are moved into a subdirectory `inst` and all classes are renamed from `.class` to
 `.classdata`, ensuring applications with any sort of automatic classpath scanning will not find
-agent classes. The agent classloader understands this convention and unobfuscates when loading
+agent classes. The agent class loader understands this convention and unobfuscates when loading
 classes.
 
 ## Smoke tests

docs/safety-mechanisms.md

@@ -198,7 +198,7 @@ fun createInstrumentationClassloader(): ClassLoader {
 }
 
 fun classpathLoader(classpath: FileCollection, parent: ClassLoader): ClassLoader {
-  logger.info("Adding to classloader:")
+  logger.info("Adding to class loader:")
   val urls: Array<URL> = StreamSupport.stream(classpath.spliterator(), false)
     .map {
       logger.info("--${it}")
@@ -294,7 +294,7 @@ fun addMuzzleTask(muzzleDirective: MuzzleDirective, versionArtifact: Artifact?,
         if (thread.contextClassLoader === instrumentationCL
           || thread.contextClassLoader === userCL) {
           throw GradleException(
-            "Task ${taskName} has spawned a thread: ${thread} with classloader ${thread.contextClassLoader}. " +
+            "Task ${taskName} has spawned a thread: ${thread} with class loader ${thread.contextClassLoader}. " +
               "This will prevent GC of dynamic muzzle classes. Aborting muzzle run.")
         }
       }
@@ -306,7 +306,7 @@ fun addMuzzleTask(muzzleDirective: MuzzleDirective, versionArtifact: Artifact?,
 }
 
 fun createClassLoaderForTask(muzzleTaskConfiguration: Configuration): ClassLoader {
-  logger.info("Creating user classloader for muzzle check")
+  logger.info("Creating user class loader for muzzle check")
   val muzzleBootstrapShadowJar = shadowMuzzleBootstrap.get().archiveFile.get()
   return classpathLoader(muzzleTaskConfiguration + files(muzzleBootstrapShadowJar), ClassLoader.getPlatformClassLoader())
 }

gradle-plugins/src/main/kotlin/io.opentelemetry.instrumentation.muzzle-check.gradle.kts

@@ -5,21 +5,21 @@
 
 package io.opentelemetry.javaagent.muzzle.generation
 
-import java.io.File
-import java.net.URL
-import java.net.URLClassLoader
 import net.bytebuddy.ByteBuddy
 import net.bytebuddy.build.Plugin
 import net.bytebuddy.description.type.TypeDescription
 import net.bytebuddy.dynamic.ClassFileLocator
 import net.bytebuddy.dynamic.DynamicType
+import java.io.File
+import java.net.URL
+import java.net.URLClassLoader
 
 /**
  * Starting from version 1.10.15, ByteBuddy gradle plugin transformations require that plugin
  * classes are given as class instances instead of a class name string. To be able to still use a
  * plugin implementation that is not a buildscript dependency, this reimplements the previous logic
  * by taking a delegate class name and class path as arguments and loading the plugin class from the
- * provided classloader when the plugin is instantiated.
+ * provided class loader when the plugin is instantiated.
  */
 class ClasspathByteBuddyPlugin(
   classPath: Iterable<File>,

gradle-plugins/src/main/kotlin/io/opentelemetry/javaagent/muzzle/generation/ClasspathByteBuddyPlugin.kt

@@ -26,7 +26,7 @@ package io.opentelemetry.javaagent.muzzle.matcher
  */
 
 // TODO the next line is not true anymore. Switch from System.err to Gradle logger.
-// Runs in special classloader so tedious to provide access to the Gradle logger.
+// Runs in special class loader so tedious to provide access to the Gradle logger.
 class MuzzleGradlePluginUtil {
 
   companion object {
@@ -58,10 +58,10 @@ class MuzzleGradlePluginUtil {
       val matcherClass = agentClassLoader.loadClass("io.opentelemetry.javaagent.tooling.muzzle.ClassLoaderMatcher")
 
       // We cannot reference Mismatch class directly here, because we are loaded from a different
-      // classloader.
+      // class loader.
 
       // We cannot reference Mismatch class directly here, because we are loaded from a different
-      // classloader.
+      // class loader.
       val allMismatches = matcherClass
         .getMethod("matchesAll", ClassLoader::class.java, Boolean::class.javaPrimitiveType, Set::class.java)
         .invoke(null, userClassLoader, assertPass, excludedInstrumentationNames)

gradle-plugins/src/main/kotlin/io/opentelemetry/javaagent/muzzle/matcher/MuzzleGradlePluginUtil.kt

@@ -13,7 +13,7 @@ import static io.opentelemetry.instrumentation.test.utils.GcUtils.awaitGc
 
 class ResourceInjectionTest extends AgentInstrumentationSpecification {
 
-  def "resources injected to non-delegating classloader"() {
+  def "resources injected to non-delegating class loader"() {
     setup:
     String resourceName = 'test-resources/test-resource.txt'
     URL[] urls = [SystemUtils.getProtectionDomain().getCodeSource().getLocation()]

instrumentation/internal/internal-class-loader/javaagent-integration-tests/src/test/groovy/ResourceInjectionTest.groovy

@@ -76,7 +76,7 @@ public static class Holder {
 
     /**
      * We have to make sure that {@link BootstrapPackagePrefixesHolder} is loaded from bootstrap
-     * classloader. After that we can use in {@link LoadClassAdvice}.
+     * class loader. After that we can use in {@link LoadClassAdvice}.
      */
     private static List<String> findBootstrapPackagePrefixes() {
       try {

instrumentation/internal/internal-class-loader/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/internal/classloader/BootDelegationInstrumentation.java

@@ -13,7 +13,7 @@
 import reactor.core.Scannable;
 import reactor.core.publisher.Mono;
 
-// Isolated test to use clean classloader because reactor instrumentation is applied on static
+// Isolated test to use clean class loader because reactor instrumentation is applied on static
 // initialization.
 class InitializationTest {
 

instrumentation/reactor/reactor-3.1/javaagent/src/testInitialization/java/io/opentelemetry/javaagent/instrumentation/reactor/InitializationTest.java

@@ -24,8 +24,8 @@ public SpringBootActuatorInstrumentationModule() {
   public void registerHelperResources(HelperResourceBuilder helperResourceBuilder) {
     // autoconfigure classes are loaded as resources using ClassPathResource
     // this line will make OpenTelemetryMeterRegistryAutoConfiguration available to all
-    // classloaders, so that the bean classloader (different than the instrumented classloader) can
-    // load it
+    // classloaders, so that the bean class loader (different than the instrumented class loader)
+    // can load it
     helperResourceBuilder.registerForAllClassLoaders(
         "io/opentelemetry/javaagent/instrumentation/spring/actuator/OpenTelemetryMeterRegistryAutoConfiguration.class");
   }

instrumentation/spring/spring-boot-actuator-autoconfigure-2.0/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/spring/actuator/SpringBootActuatorInstrumentationModule.java

@@ -20,14 +20,14 @@
  * them as different keys then.
  *
  * <p>That is why this class exists and resides in a separate package. This package is treated in a
- * special way and is always loaded by bootstrap classloader. This makes sure that this class is
- * available to all tracers from every classloader.
+ * special way and is always loaded by bootstrap class loader. This makes sure that this class is
+ * available to all tracers from every class loader.
  *
- * <p>But at the same time, being loaded by bootstrap classloader, this class itself cannot initiate
- * the loading of {@code io.undertow.util.AttachmentKey} class. Class has to be loaded by <i>any</i>
- * classloader that has it, e.g. by the classloader of a Tracer that uses this key holder. After
- * that, <i>all</i> Tracers, loaded by all classloaders, will be able to use exactly the same sole
- * instance of the key.
+ * <p>But at the same time, being loaded by bootstrap class loader, this class itself cannot
+ * initiate the loading of {@code io.undertow.util.AttachmentKey} class. Class has to be loaded by
+ * <i>any</i> class loader that has it, e.g. by the class loader of a Tracer that uses this key
+ * holder. After that, <i>all</i> Tracers, loaded by all class loaders, will be able to use exactly
+ * the same sole instance of the key.
  */
 public final class KeyHolder {
   public static final ConcurrentMap<Class<?>, Object> contextKeys = new ConcurrentHashMap<>();

instrumentation/undertow-1.4/bootstrap/src/main/java/io/opentelemetry/javaagent/bootstrap/undertow/KeyHolder.java

@@ -22,10 +22,10 @@
  * <p>The bootstrap process of the agent is somewhat complicated and care has to be taken to make
  * sure things do not get broken by accident.
  *
- * <p>JVM loads this class onto app's classloader, afterwards agent needs to inject its classes onto
- * bootstrap classpath. This leads to this class being visible on bootstrap. This in turn means that
- * this class may be loaded again on bootstrap by accident if we ever reference it after bootstrap
- * has been setup.
+ * <p>JVM loads this class onto app's class loader, afterwards agent needs to inject its classes
+ * onto bootstrap classpath. This leads to this class being visible on bootstrap. This in turn means
+ * that this class may be loaded again on bootstrap by accident if we ever reference it after
+ * bootstrap has been setup.
  *
  * <p>In order to avoid this we need to make sure we do a few things:
  *

javaagent-bootstrap/src/main/java/io/opentelemetry/javaagent/OpenTelemetryAgent.java

@@ -28,7 +28,7 @@
 /**
  * Classloader used to run the core agent.
  *
- * <p>It is built around the concept of a jar inside another jar. This classloader loads the files
+ * <p>It is built around the concept of a jar inside another jar. This class loader loads the files
  * of the internal jar to load classes and resources.
  */
 public class AgentClassLoader extends URLClassLoader {
@@ -324,7 +324,7 @@ public BootstrapClassLoaderProxy getBootstrapProxy() {
   }
 
   /**
-   * A stand-in for the bootstrap classloader. Used to look up bootstrap resources and resources
+   * A stand-in for the bootstrap class loader. Used to look up bootstrap resources and resources
    * appended by instrumentation.
    *
    * <p>This class is thread safe.

javaagent-bootstrap/src/main/java/io/opentelemetry/javaagent/bootstrap/AgentClassLoader.java

@@ -15,7 +15,7 @@
  *
  * <p>This class is loaded and called by {@code io.opentelemetry.javaagent.OpenTelemetryAgent}
  *
- * <p>The intention is for this class to be loaded by bootstrap classloader to make sure we have
+ * <p>The intention is for this class to be loaded by bootstrap class loader to make sure we have
  * unimpeded access to the rest of agent parts.
  */
 public final class AgentInitializer {
@@ -91,11 +91,11 @@ public static ClassLoader getExtensionsClassLoader() {
   }
 
   /**
-   * Create the agent classloader. This must be called after the bootstrap jar has been appended to
+   * Create the agent class loader. This must be called after the bootstrap jar has been appended to
    * the bootstrap classpath.
    *
-   * @param innerJarFilename Filename of internal jar to use for the classpath of the agent
-   *     classloader
+   * @param innerJarFilename Filename of internal jar to use for the classpath of the agent class
+   *     loader
    * @return Agent Classloader
    */
   private static ClassLoader createAgentClassLoader(String innerJarFilename, File javaagentFile) {

javaagent-bootstrap/src/main/java/io/opentelemetry/javaagent/bootstrap/AgentInitializer.java

@@ -10,11 +10,11 @@
 
 /**
  * {@link BootstrapPackagePrefixesHolder} is an utility class that holds package prefixes. The
- * classes from these packages are pushed to the bootstrap classloader.
+ * classes from these packages are pushed to the bootstrap class loader.
  *
- * <p>The prefixes are loaded by {@code AgentInstaller} and consumed by classloader instrumentation.
- * The instrumentation does not have access to the installer, therefore this utility class is used
- * to share package prefixes.
+ * <p>The prefixes are loaded by {@code AgentInstaller} and consumed by class loader
+ * instrumentation. The instrumentation does not have access to the installer, therefore this
+ * utility class is used to share package prefixes.
  */
 public final class BootstrapPackagePrefixesHolder {