-
Notifications
You must be signed in to change notification settings - Fork 791
/
MuzzleGradlePluginUtil.kt
102 lines (93 loc) · 4.5 KB
/
MuzzleGradlePluginUtil.kt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
/*
* Copyright The OpenTelemetry Authors
* SPDX-License-Identifier: Apache-2.0
*/
package io.opentelemetry.javaagent.muzzle.matcher
/**
* Entry point for the muzzle gradle plugin.
*
* <p>In order to understand this class and its weirdness, one has to remember that there are three
* different independent class loaders at play here.
*
* <p>First, Gradle class loader that has loaded the muzzle-check plugin that calls this class. This
* one has a lot of Gradle specific stuff and we don't want it to be available during muzzle checks.
*
* <p>Second, there is agent or instrumentation class loader, which contains all
* InstrumentationModules and helper classes. The actual muzzle check process happens "inside" that
* class loader. This means that we load {@code
* io.opentelemetry.javaagent.tooling.muzzle.ClassLoaderMatcher} from it and we allow it to find all
* InstrumentationModules from agent class loader.
*
* <p>Finally, there is user class loader. It contains the specific version of the instrumented
* library that we want to muzzle-check: "does this version provide all the expected hooks and
* classes and methods that our instrumentations expect".
*/
// 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.
class MuzzleGradlePluginUtil {
companion object {
/**
* Verifies that all instrumentations present in the {@code agentClassLoader} can be safely
* applied to the passed {@code userClassLoader}.
*
* <p>This method throws whenever one of the following step fails (and {@code assertPass} is
* true):
*
* <ol>
* <li>{@code userClassLoader} is not matched by the {@code
* InstrumentationModule#classLoaderMatcher()} method
* <li>{@code ReferenceMatcher} of any instrumentation module finds any mismatch
* <li>any helper class defined in {@code InstrumentationModule#getMuzzleHelperClassNames()}
* fails to be injected into {@code userClassLoader}
* </ol>
*
* <p>When {@code assertPass = false} this method behaves in an opposite way: failure in any of
* the first two steps is expected (helper classes are not injected at all).
*
* <p>This method is repeatedly called by the {@code :muzzle} gradle task - each tested dependency
* version passes different {@code userClassLoader}.
*/
@Suppress("UNCHECKED_CAST")
fun assertInstrumentationMuzzled(agentClassLoader: ClassLoader, userClassLoader: ClassLoader, assertPass: Boolean) {
val matcherClass = agentClassLoader.loadClass("io.opentelemetry.javaagent.tooling.muzzle.ClassLoaderMatcher")
// We cannot reference Mismatch class directly here, because we are loaded from a differen
// classloader.
// We cannot reference Mismatch class directly here, because we are loaded from a differen
// classloader.
val allMismatches = matcherClass
.getMethod("matchesAll", ClassLoader::class.java, Boolean::class.javaPrimitiveType)
.invoke(null, userClassLoader, assertPass)
as Map<String, List<Any>>
allMismatches.forEach { moduleName, mismatches ->
val passed = mismatches.isEmpty()
if (passed && !assertPass) {
System.err.println("MUZZLE PASSED $moduleName BUT FAILURE WAS EXPECTED")
throw IllegalStateException("Instrumentation unexpectedly passed Muzzle validation")
} else if (!passed && assertPass) {
System.err.println("FAILED MUZZLE VALIDATION: $moduleName mismatches:")
for (mismatch in mismatches) {
System.err.println("-- $mismatch")
}
throw IllegalStateException("Instrumentation failed Muzzle validation")
}
}
val validatedModulesCount = allMismatches.size
if (validatedModulesCount == 0) {
val errorMessage = "Did not found any InstrumentationModule to validate!"
System.err.println(errorMessage)
throw IllegalStateException(errorMessage)
}
}
/**
* Prints all references from all instrumentation modules present in the passed {@code
* instrumentationClassLoader}.
*
* <p>Called by the {@code printMuzzleReferences} gradle task.
*/
fun printMuzzleReferences(instrumentationClassLoader: ClassLoader) {
val matcherClass = instrumentationClassLoader.loadClass(
"io.opentelemetry.javaagent.tooling.muzzle.ReferencesPrinter")
matcherClass.getMethod("printMuzzleReferences").invoke(null)
}
}
}