open-telemetry
/
opentelemetry-java-instrumentation
mirror of https://github.com/open-telemetry/opentelemetry-java-instrumentation.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1146 from DataDog/tyler/boostrap-log-exception 

Add better exception handling in Agent initialization
This commit is contained in:
Tyler Benson 2019-12-17 22:03:42 -08:00 committed by GitHub
parent fc59355a69 96edbe8b8a
commit b3f15ca133
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 79 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
dd-java-agent/agent-bootstrap/src/main/java/datadog/trace/bootstrap/Agent.java
View File

@ -16,6 +16,7 @@ import org.slf4j.LoggerFactory;
* <p>The intention is for this class to be loaded by bootstrap classloader to make sure we have
* unimpeded access to the rest of Datadog's agent parts.
*/
// We cannot use lombok here because we need to configure logger first
public class Agent {
private static final String SIMPLE_LOGGER_SHOW_DATE_TIME_PROPERTY =
@ -28,19 +29,19 @@ public class Agent {
"datadog.slf4j.simpleLogger.defaultLogLevel";
// We cannot use lombok here because we need to configure logger first
private static final Logger LOGGER;
private static final Logger log;
static {
// We can configure logger here because datadog.trace.agent.AgentBootstrap doesn't touch it.
configureLogger();
LOGGER = LoggerFactory.getLogger(Agent.class);
log = LoggerFactory.getLogger(Agent.class);
}
// fields must be managed under class lock
private static ClassLoader AGENT_CLASSLOADER = null;
private static ClassLoader JMXFETCH_CLASSLOADER = null;
public static void start(final Instrumentation inst, final URL bootstrapURL) throws Exception {
public static void start(final Instrumentation inst, final URL bootstrapURL) {
startDatadogAgent(inst, bootstrapURL);
final boolean appUsingCustomLogManager = isAppUsingCustomLogManager();
@ -59,10 +60,10 @@ public class Agent {
* the global log manager and jmxfetch won't be able to touch it due to classloader locking.
*/
if (appUsingCustomLogManager) {
LOGGER.debug("Custom logger detected. Delaying JMXFetch initialization.");
registerLogManagerCallback(new StartJmxFetchCallback(inst, bootstrapURL));
log.debug("Custom logger detected. Delaying JMXFetch initialization.");
registerLogManagerCallback(new StartJmxFetchCallback(bootstrapURL));
} else {
startJmxFetch(inst, bootstrapURL);
startJmxFetch(bootstrapURL);
}
/*
@ -71,28 +72,30 @@ public class Agent {
* logging facility.
*/
if (isJavaBefore9WithJFR() && appUsingCustomLogManager) {
LOGGER.debug("Custom logger detected. Delaying Datadog Tracer initialization.");
registerLogManagerCallback(new InstallDatadogTracerCallback(inst, bootstrapURL));
log.debug("Custom logger detected. Delaying Datadog Tracer initialization.");
registerLogManagerCallback(new InstallDatadogTracerCallback(bootstrapURL));
} else {
installDatadogTracer(inst, bootstrapURL);
installDatadogTracer();
}
}
private static void registerLogManagerCallback(final Runnable callback) throws Exception {
final Class<?> agentInstallerClass =
AGENT_CLASSLOADER.loadClass("datadog.trace.agent.tooling.AgentInstaller");
final Method registerCallbackMethod =
agentInstallerClass.getMethod("registerClassLoadCallback", String.class, Runnable.class);
registerCallbackMethod.invoke(null, "java.util.logging.LogManager", callback);
private static void registerLogManagerCallback(final ClassLoadCallBack callback) {
try {
final Class<?> agentInstallerClass =
AGENT_CLASSLOADER.loadClass("datadog.trace.agent.tooling.AgentInstaller");
final Method registerCallbackMethod =
agentInstallerClass.getMethod("registerClassLoadCallback", String.class, Runnable.class);
registerCallbackMethod.invoke(null, "java.util.logging.LogManager", callback);
} catch (final Exception ex) {
log.error("Error registering callback for " + callback.getName(), ex);
}
}
protected abstract static class ClassLoadCallBack implements Runnable {
final Instrumentation inst;
final URL bootstrapURL;
ClassLoadCallBack(final Instrumentation inst, final URL bootstrapURL) {
this.inst = inst;
ClassLoadCallBack(final URL bootstrapURL) {
this.bootstrapURL = bootstrapURL;
}
@ -111,7 +114,7 @@ public class Agent {
try {
execute();
} catch (final Exception e) {
LOGGER.error("Failed to run class loader callback {}", getName(), e);
log.error("Failed to run class loader callback {}", getName(), e);
}
}
});
@ -122,12 +125,12 @@ public class Agent {
public abstract String getName();
public abstract void execute() throws Exception;
public abstract void execute();
}
protected static class StartJmxFetchCallback extends ClassLoadCallBack {
StartJmxFetchCallback(final Instrumentation inst, final URL bootstrapURL) {
super(inst, bootstrapURL);
StartJmxFetchCallback(final URL bootstrapURL) {
super(bootstrapURL);
}
@Override
@ -136,14 +139,14 @@ public class Agent {
}
@Override
public void execute() throws Exception {
startJmxFetch(inst, bootstrapURL);
public void execute() {
startJmxFetch(bootstrapURL);
}
}
protected static class InstallDatadogTracerCallback extends ClassLoadCallBack {
InstallDatadogTracerCallback(final Instrumentation inst, final URL bootstrapURL) {
super(inst, bootstrapURL);
InstallDatadogTracerCallback(final URL bootstrapURL) {
super(bootstrapURL);
}
@Override
@ -152,18 +155,18 @@ public class Agent {
}
@Override
public void execute() throws Exception {
installDatadogTracer(inst, bootstrapURL);
public void execute() {
installDatadogTracer();
}
}
private static synchronized void startDatadogAgent(
final Instrumentation inst, final URL bootstrapURL) throws Exception {
final Instrumentation inst, final URL bootstrapURL) {
if (AGENT_CLASSLOADER == null) {
final ClassLoader agentClassLoader =
createDatadogClassLoader("agent-tooling-and-instrumentation.isolated", bootstrapURL);
final ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
try {
final ClassLoader agentClassLoader =
createDatadogClassLoader("agent-tooling-and-instrumentation.isolated", bootstrapURL);
Thread.currentThread().setContextClassLoader(agentClassLoader);
final Class<?> agentInstallerClass =
agentClassLoader.loadClass("datadog.trace.agent.tooling.AgentInstaller");
@ -171,14 +174,15 @@ public class Agent {
agentInstallerClass.getMethod("installBytebuddyAgent", Instrumentation.class);
agentInstallerMethod.invoke(null, inst);
AGENT_CLASSLOADER = agentClassLoader;
} catch (final Throwable ex) {
log.error("Throwable thrown while installing the Datadog Agent", ex);
} finally {
Thread.currentThread().setContextClassLoader(contextLoader);
}
}
}
private static synchronized void installDatadogTracer(
final Instrumentation inst, final URL bootstrapURL) throws Exception {
private static synchronized void installDatadogTracer() {
if (AGENT_CLASSLOADER == null) {
throw new IllegalStateException("Datadog agent should have been started already");
}
@ -194,24 +198,27 @@ public class Agent {
tracerInstallerMethod.invoke(null);
final Method logVersionInfoMethod = tracerInstallerClass.getMethod("logVersionInfo");
logVersionInfoMethod.invoke(null);
} catch (final Throwable ex) {
log.error("Throwable thrown while installing the Datadog Tracer", ex);
} finally {
Thread.currentThread().setContextClassLoader(contextLoader);
}
}
private static synchronized void startJmxFetch(final Instrumentation inst, final URL bootstrapURL)
throws Exception {
private static synchronized void startJmxFetch(final URL bootstrapURL) {
if (JMXFETCH_CLASSLOADER == null) {
final ClassLoader jmxFetchClassLoader =
createDatadogClassLoader("agent-jmxfetch.isolated", bootstrapURL);
final ClassLoader contextLoader = Thread.currentThread().getContextClassLoader();
try {
final ClassLoader jmxFetchClassLoader =
createDatadogClassLoader("agent-jmxfetch.isolated", bootstrapURL);
Thread.currentThread().setContextClassLoader(jmxFetchClassLoader);
final Class<?> jmxFetchAgentClass =
jmxFetchClassLoader.loadClass("datadog.trace.agent.jmxfetch.JMXFetch");
final Method jmxFetchInstallerMethod = jmxFetchAgentClass.getMethod("run");
jmxFetchInstallerMethod.invoke(null);
JMXFETCH_CLASSLOADER = jmxFetchClassLoader;
} catch (final Throwable ex) {
log.error("Throwable thrown while starting JmxFetch", ex);
} finally {
Thread.currentThread().setContextClassLoader(contextLoader);
}
@ -305,8 +312,8 @@ public class Agent {
System.getenv(tracerCustomLogManSysprop.replace('.', '_').toUpperCase());
if (customLogManagerProp != null || customLogManagerEnv != null) {
LOGGER.debug("Prop - customlogmanager: " + customLogManagerProp);
LOGGER.debug("Env - customlogmanager: " + customLogManagerEnv);
log.debug("Prop - customlogmanager: " + customLogManagerProp);
log.debug("Env - customlogmanager: " + customLogManagerEnv);
// Allow setting to skip these automatic checks:
return Boolean.parseBoolean(customLogManagerProp)
|| Boolean.parseBoolean(customLogManagerEnv);
@ -314,7 +321,7 @@ public class Agent {
final String jbossHome = System.getenv("JBOSS_HOME");
if (jbossHome != null) {
LOGGER.debug("Env - jboss: " + jbossHome);
log.debug("Env - jboss: " + 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.
@ -327,8 +334,8 @@ public class Agent {
if (logManagerProp != null) {
final boolean onSysClasspath =
ClassLoader.getSystemResource(logManagerProp.replaceAll("\\.", "/") + ".class") != null;
LOGGER.debug("Prop - logging.manager: " + logManagerProp);
LOGGER.debug("logging.manager on system classpath: " + onSysClasspath);
log.debug("Prop - logging.manager: " + logManagerProp);
log.debug("logging.manager on system classpath: " + onSysClasspath);
// 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 jmxfetch which will setup the log manager.

28
dd-java-agent/src/main/java/datadog/trace/bootstrap/AgentBootstrap.java
View File

@ -41,19 +41,23 @@ import java.util.regex.Pattern;
*/
public class AgentBootstrap {
public static void premain(final String agentArgs, final Instrumentation inst) throws Exception {
public static void premain(final String agentArgs, final Instrumentation inst) {
agentmain(agentArgs, inst);
}
public static void agentmain(final String agentArgs, final Instrumentation inst)
throws Exception {
public static void agentmain(final String agentArgs, final Instrumentation inst) {
try {
final URL bootstrapURL = installBootstrapJar(inst);
final URL bootstrapURL = installBootstrapJar(inst);
final Class<?> agentClass =
ClassLoader.getSystemClassLoader().loadClass("datadog.trace.bootstrap.Agent");
final Method startMethod = agentClass.getMethod("start", Instrumentation.class, URL.class);
startMethod.invoke(null, inst, bootstrapURL);
final Class<?> agentClass =
ClassLoader.getSystemClassLoader().loadClass("datadog.trace.bootstrap.Agent");
final Method startMethod = agentClass.getMethod("start", Instrumentation.class, URL.class);
startMethod.invoke(null, inst, bootstrapURL);
} catch (final Throwable ex) {
// Don't rethrow. We don't have a log manager here, so just print.
ex.printStackTrace();
}
}
private static synchronized URL installBootstrapJar(final Instrumentation inst)
@ -106,8 +110,12 @@ public class AgentBootstrap {
throw new RuntimeException("Unable to parse javaagent parameter: " + agentArgument);
}
bootstrapURL = new URL("file:" + matcher.group(1));
inst.appendToBootstrapClassLoaderSearch(new JarFile(new File(bootstrapURL.toURI())));
final File javaagentFile = new File(matcher.group(1));
if (!(javaagentFile.exists() || javaagentFile.isFile())) {
throw new RuntimeException("Unable to find javaagent file: " + javaagentFile);
}
bootstrapURL = javaagentFile.toURI().toURL();
inst.appendToBootstrapClassLoaderSearch(new JarFile(javaagentFile));
return bootstrapURL;
}

2
dd-java-agent/src/test/groovy/datadog/trace/agent/AgentLoadedIntoBootstrapTest.groovy
View File

@ -5,7 +5,7 @@ import jvmbootstraptest.AgentLoadedChecker
import spock.lang.Specification
class AgentLoadedIntoBootstrapTest extends Specification {
def "Agent loads in when separate jvm is launched"() {
expect:
IntegrationTestUtils.runOnSeparateJvm(AgentLoadedChecker.getName()

11
dd-java-agent/src/test/groovy/datadog/trace/agent/JMXFetchTest.groovy
View File

@ -2,6 +2,7 @@ package datadog.trace.agent
import datadog.trace.agent.test.IntegrationTestUtils
import datadog.trace.api.Config
import jvmbootstraptest.AgentLoadedChecker
import org.junit.Rule
import org.junit.contrib.java.lang.system.RestoreSystemProperties
import spock.lang.Specification
@ -49,6 +50,16 @@ class JMXFetchTest extends Specification {
Thread.currentThread().setContextClassLoader(currentContextLoader)
}
def "Agent loads when JmxFetch is misconfigured"() {
// verify the agent starts up correctly with a bogus address.
expect:
IntegrationTestUtils.runOnSeparateJvm(AgentLoadedChecker.getName()
, ["-Ddd.jmxfetch.enabled=true", "-Ddd.jmxfetch.statsd.host=example.local"] as String[]
, "" as String[]
, [:]
, true) == 0
}
def "test jmxfetch config"() {
setup:
names.each {