Merge pull request #980 from microsoft/buildme/add-custom-instrumentation

Bring back custom agent instrumentation

Author: trask

agent/build.gradle

@@ -136,6 +136,8 @@ dependencies {
     runtime "org.glowroot.instrumentation:instrumentation-http-url-connection:$instrumentationVersion"
     runtime "org.glowroot.instrumentation:instrumentation-log4j:$instrumentationVersion"
     runtime "org.glowroot.instrumentation:instrumentation-logback:$instrumentationVersion"
+
+    testCompile 'junit:junit:4.12'
 }
 
 // region Publishing properties

agent/src/main/java/com/microsoft/applicationinsights/agent/internal/AIAgentXmlLoader.java

@@ -29,24 +29,40 @@
 import java.util.List;
 import java.util.Map;
 
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Splitter;
+import com.microsoft.applicationinsights.agent.internal.config.AgentConfiguration;
 import com.microsoft.applicationinsights.agent.internal.config.BuiltInInstrumentation;
-import com.microsoft.applicationinsights.agent.internal.config.XmlAgentConfigurationBuilder;
+import com.microsoft.applicationinsights.agent.internal.config.ClassInstrumentationData;
+import com.microsoft.applicationinsights.agent.internal.config.MethodInfo;
+import com.microsoft.applicationinsights.agent.internal.config.builder.XmlAgentConfigurationBuilder;
+import org.glowroot.instrumentation.engine.config.AdviceConfig;
+import org.glowroot.instrumentation.engine.config.AdviceConfig.CaptureKind;
+import org.glowroot.instrumentation.engine.config.ImmutableAdviceConfig;
+import org.glowroot.instrumentation.engine.config.ImmutableInstrumentationDescriptor;
 import org.glowroot.instrumentation.engine.config.InstrumentationDescriptor;
 import org.glowroot.instrumentation.engine.config.InstrumentationDescriptors;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.commons.Method;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 class AIAgentXmlLoader {
 
-    static BuiltInInstrumentation load(File agentJarParentFile) {
+    private static final Logger logger = LoggerFactory.getLogger(AIAgentXmlLoader.class);
+
+    static AgentConfiguration load(File agentJarParentFile) {
         return new XmlAgentConfigurationBuilder().parseConfigurationFile(agentJarParentFile.getAbsolutePath());
     }
 
-    static List<InstrumentationDescriptor> getInstrumentationDescriptors(
-            BuiltInInstrumentation builtInInstrumentation) throws IOException {
+    static List<InstrumentationDescriptor> getInstrumentationDescriptors(AgentConfiguration agentConfiguration)
+            throws IOException {
 
-        boolean httpEnabled = builtInInstrumentation.isHttpEnabled();
-        boolean jdbcEnabled = builtInInstrumentation.isJdbcEnabled();
-        boolean loggingEnabled = builtInInstrumentation.isLoggingEnabled();
-        boolean redisEnabled = builtInInstrumentation.isJedisEnabled();
+        BuiltInInstrumentation builtInConfiguration = agentConfiguration.getBuiltInInstrumentation();
+        boolean httpEnabled = builtInConfiguration.isHttpEnabled();
+        boolean jdbcEnabled = builtInConfiguration.isJdbcEnabled();
+        boolean loggingEnabled = builtInConfiguration.isLoggingEnabled();
+        boolean redisEnabled = builtInConfiguration.isJedisEnabled();
 
         List<InstrumentationDescriptor> instrumentationDescriptors = new ArrayList<>();
         for (InstrumentationDescriptor instrumentationDescriptor : InstrumentationDescriptors.read()) {
@@ -79,6 +95,12 @@ static List<InstrumentationDescriptor> getInstrumentationDescriptors(
                     break;
             }
         }
+
+        InstrumentationDescriptor instrumentationDescriptor = buildCustomInstrumentation(agentConfiguration);
+        if (instrumentationDescriptor != null) {
+            System.out.println(instrumentationDescriptor);
+            instrumentationDescriptors.add(instrumentationDescriptor);
+        }
         return instrumentationDescriptors;
     }
 
@@ -102,4 +124,106 @@ static Map<String, Map<String, Object>> getInstrumentationConfig(BuiltInInstrume
 
         return instrumentationConfiguration;
     }
+
+
+    private static InstrumentationDescriptor buildCustomInstrumentation(AgentConfiguration agentConfiguration) {
+
+        List<AdviceConfig> adviceConfigs = new ArrayList<>();
+
+        for (Map.Entry<String, ClassInstrumentationData> classEntry : agentConfiguration.getClassesToInstrument()
+                .entrySet()) {
+
+            String className = classEntry.getKey();
+            if (!validJavaFqcn(className)) {
+                // this is needed to prevent glowroot wildcard from being used for now
+                // and also to prevent commas in the class name which would cause parsing issues in LocalSpanImpl
+                logger.warn("Invalid class name: {}", className);
+                continue;
+            }
+            ClassInstrumentationData classInstrumentationData = classEntry.getValue();
+
+            for (Map.Entry<String, Map<String, MethodInfo>> methodNameEntry :
+                    classInstrumentationData.getMethodInfos().entrySet()) {
+
+                String methodName = methodNameEntry.getKey();
+                if (!validJavaIdentifier(methodName)) {
+                    // this is needed to prevent glowroot wildcard from being used for now
+                    // and also to prevent commas in the method name which would cause parsing issues in LocalSpanImpl
+                    logger.warn("Invalid method name: {}", methodName);
+                    continue;
+                }
+
+                Map<String, MethodInfo> methodInfos = methodNameEntry.getValue();
+
+                for (Map.Entry<String, MethodInfo> entry : methodInfos.entrySet()) {
+
+                    MethodInfo methodInfo = entry.getValue();
+                    String signature = entry.getKey();
+
+                    ImmutableAdviceConfig.Builder adviceConfig = ImmutableAdviceConfig.builder()
+                            .className(className)
+                            .methodName(methodName);
+
+                    if (signature.equals(ClassInstrumentationData.ANY_SIGNATURE_MARKER)) {
+                        adviceConfig.addMethodParameterTypes("..");
+                    } else {
+                        Method method = new Method(methodName, signature);
+                        for (Type type : method.getArgumentTypes()) {
+                            adviceConfig.addMethodParameterTypes(type.getClassName());
+                        }
+                        adviceConfig.methodReturnType(method.getReturnType().getClassName());
+                    }
+
+                    adviceConfigs.add(adviceConfig.captureKind(CaptureKind.LOCAL_SPAN)
+                            // advice config doesn't support threshold, so threshold is embedded into message
+                            // and then parsed out by the agent to decide whether to report telemetry
+                            .spanMessageTemplate(
+                                    "__custom," + className + "," + methodName + "," + methodInfo.getThresholdInMS() +
+                                            "," + classInstrumentationData.getClassType())
+                            .timerName("custom")
+                            .build());
+                }
+            }
+        }
+
+        if (adviceConfigs.isEmpty()) {
+            return null;
+        } else {
+            return ImmutableInstrumentationDescriptor.builder()
+                    .id("__custom")
+                    .name("__custom")
+                    .addAllAdviceConfigs(adviceConfigs)
+                    .build();
+        }
+    }
+
+    @VisibleForTesting
+    static boolean validJavaFqcn(String fqcn) {
+        List<String> parts = Splitter.on('.').splitToList(fqcn);
+        if (parts.isEmpty()) {
+            return false;
+        }
+        for (int i = 0; i < parts.size() - 1; i++) {
+            if (!validJavaIdentifier(parts.get(i))) {
+                return false;
+            }
+        }
+        return validJavaIdentifier(parts.get(parts.size() - 1));
+    }
+
+    @VisibleForTesting
+    static boolean validJavaIdentifier(String identifier) {
+        if (identifier.isEmpty()) {
+            return false;
+        }
+        if (!Character.isJavaIdentifierStart(identifier.charAt(0))) {
+            return false;
+        }
+        for (int i = 1; i < identifier.length(); i++) {
+            if (!Character.isJavaIdentifierPart(identifier.charAt(i))) {
+                return false;
+            }
+        }
+        return true;
+    }
 }

agent/src/main/java/com/microsoft/applicationinsights/agent/internal/MainEntryPoint.java

@@ -26,6 +26,7 @@
 import java.util.Collections;
 import java.util.List;
 
+import com.microsoft.applicationinsights.agent.internal.config.AgentConfiguration;
 import com.microsoft.applicationinsights.agent.internal.config.BuiltInInstrumentation;
 import com.microsoft.applicationinsights.agent.internal.model.Global;
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -78,7 +79,9 @@ private static void start(Instrumentation instrumentation, File agentJarFile) th
             throw new Exception("Could not create directory: " + tmpDir.getAbsolutePath());
         }
 
-        BuiltInInstrumentation builtInInstrumentation = AIAgentXmlLoader.load(agentJarParentFile);
+        AgentConfiguration agentConfiguration = AIAgentXmlLoader.load(agentJarParentFile);
+
+        BuiltInInstrumentation builtInInstrumentation = agentConfiguration.getBuiltInInstrumentation();
 
         if (!builtInInstrumentation.isEnabled()) {
             return;
@@ -88,7 +91,7 @@ private static void start(Instrumentation instrumentation, File agentJarFile) th
         Global.setOutboundW3CBackCompatEnabled(builtInInstrumentation.isW3cBackCompatEnabled());
 
         List<InstrumentationDescriptor> instrumentationDescriptors =
-                AIAgentXmlLoader.getInstrumentationDescriptors(builtInInstrumentation);
+                AIAgentXmlLoader.getInstrumentationDescriptors(agentConfiguration);
 
         ConfigServiceFactory configServiceFactory = new SimpleConfigServiceFactory(instrumentationDescriptors,
                 AIAgentXmlLoader.getInstrumentationConfig(builtInInstrumentation));

agent/src/main/java/com/microsoft/applicationinsights/agent/internal/config/AgentConfiguration.java

@@ -0,0 +1,48 @@
+/*
+ * ApplicationInsights-Java
+ * Copyright (c) Microsoft Corporation
+ * All rights reserved.
+ *
+ * MIT License
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this
+ * software and associated documentation files (the ""Software""), to deal in the Software
+ * without restriction, including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the following conditions:
+ * The above copyright notice and this permission notice shall be included in all copies or
+ * substantial portions of the Software.
+ * THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+ * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+ * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package com.microsoft.applicationinsights.agent.internal.config;
+
+import java.util.Map;
+
+import com.microsoft.applicationinsights.agent.internal.config.builder.BuiltInInstrumentationBuilder;
+
+public class AgentConfiguration {
+
+    private Map<String, ClassInstrumentationData> classesToInstrument;
+    private BuiltInInstrumentation builtInInstrumentation = new BuiltInInstrumentationBuilder().create();
+
+    public void setClassesToInstrument(Map<String, ClassInstrumentationData> classesToInstrument) {
+        this.classesToInstrument = classesToInstrument;
+    }
+
+    public Map<String, ClassInstrumentationData> getClassesToInstrument() {
+        return classesToInstrument;
+    }
+
+    public BuiltInInstrumentation getBuiltInInstrumentation() {
+        return builtInInstrumentation;
+    }
+
+    public void setBuiltInData(BuiltInInstrumentation builtInInstrumentation) {
+        this.builtInInstrumentation = builtInInstrumentation;
+    }
+}

agent/src/main/java/com/microsoft/applicationinsights/agent/internal/config/ClassInstrumentationData.java

@@ -0,0 +1,75 @@
+/*
+ * ApplicationInsights-Java
+ * Copyright (c) Microsoft Corporation
+ * All rights reserved.
+ *
+ * MIT License
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this
+ * software and associated documentation files (the ""Software""), to deal in the Software
+ * without restriction, including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the following conditions:
+ * The above copyright notice and this permission notice shall be included in all copies or
+ * substantial portions of the Software.
+ * THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+ * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+ * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package com.microsoft.applicationinsights.agent.internal.config;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.google.common.base.Strings;
+
+public class ClassInstrumentationData {
+
+    public static final String OTHER_TYPE = "OTHER";
+
+    public static final String ANY_SIGNATURE_MARKER = "";
+
+    private final String classType;
+
+    private final long thresholdInMS;
+
+    // first key is method name, second key is signature or ANY_SIGNATURE_MARKER
+    private final Map<String, Map<String, MethodInfo>> methodInfos = new HashMap<>();
+
+    public ClassInstrumentationData(String classType, long thresholdInMS) {
+        this.classType = classType;
+        this.thresholdInMS = thresholdInMS;
+    }
+
+    public String getClassType() {
+        return classType;
+    }
+
+    public long getThresholdInMS() {
+        return thresholdInMS;
+    }
+
+    public Map<String, Map<String, MethodInfo>> getMethodInfos() {
+        return methodInfos;
+    }
+
+    public void addMethod(String methodName, String signature, long thresholdInMS) {
+
+        Map<String, MethodInfo> innerMap = methodInfos.get(methodName);
+        if (innerMap == null) {
+            innerMap = new HashMap<>();
+            methodInfos.put(methodName, innerMap);
+        }
+
+        MethodInfo methodInfo = new MethodInfo(thresholdInMS);
+
+        if (Strings.isNullOrEmpty(signature)) {
+            innerMap.put(ANY_SIGNATURE_MARKER, methodInfo);
+        } else {
+            innerMap.put(signature, methodInfo);
+        }
+    }
+}

agent/src/main/java/com/microsoft/applicationinsights/agent/internal/config/MethodInfo.java

@@ -0,0 +1,39 @@
+/*
+ * ApplicationInsights-Java
+ * Copyright (c) Microsoft Corporation
+ * All rights reserved.
+ *
+ * MIT License
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this
+ * software and associated documentation files (the ""Software""), to deal in the Software
+ * without restriction, including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+ * persons to whom the Software is furnished to do so, subject to the following conditions:
+ * The above copyright notice and this permission notice shall be included in all copies or
+ * substantial portions of the Software.
+ * THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+ * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+ * FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+package com.microsoft.applicationinsights.agent.internal.config;
+
+/**
+ * The class holds the type of actions that should be done on an instrumented method.
+ * The class is the 'decision' for the method after taking into consideration init/configuration data.
+ */
+public class MethodInfo {
+
+    private final long thresholdInMS;
+
+    public MethodInfo(long thresholdInMS) {
+        this.thresholdInMS = thresholdInMS;
+    }
+
+    public long getThresholdInMS() {
+        return thresholdInMS;
+    }
+}

agent/src/main/java/com/microsoft/applicationinsights/agent/internal/config/BuiltInInstrumentationBuilder.java renamed to agent/src/main/java/com/microsoft/applicationinsights/agent/internal/config/builder/BuiltInInstrumentationBuilder.java

@@ -19,12 +19,13 @@
  * DEALINGS IN THE SOFTWARE.
  */
 
-package com.microsoft.applicationinsights.agent.internal.config;
+package com.microsoft.applicationinsights.agent.internal.config.builder;
 
+import com.microsoft.applicationinsights.agent.internal.config.BuiltInInstrumentation;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-class BuiltInInstrumentationBuilder {
+public class BuiltInInstrumentationBuilder {
 
     private static final Logger logger = LoggerFactory.getLogger(BuiltInInstrumentationBuilder.class);