Add a plugin that supports the Solon framework.

apm-protocol/apm-network/src/main/java/org/apache/skywalking/apm/network/trace/component/ComponentsDefine.java

@@ -257,5 +257,6 @@ public class ComponentsDefine {
 
     public static final OfficialComponent OCEANBASE_JDBC_DRIVER = new OfficialComponent(157, "OceanBase-jdbc-driver");
 
+    public static final OfficialComponent SOLON_MVC = new OfficialComponent(158, "SolonMVC");
 
 }

apm-sniffer/apm-sdk-plugin/solon-2.x-plugin/pom.xml

@@ -0,0 +1,48 @@
+<?xml version="1.0"?>
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one or more
+  ~ contributor license agreements.  See the NOTICE file distributed with
+  ~ this work for additional information regarding copyright ownership.
+  ~ The ASF licenses this file to You under the Apache License, Version 2.0
+  ~ (the "License"); you may not use this file except in compliance with
+  ~ the License.  You may obtain a copy of the License at
+  ~
+  ~     http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  ~
+  -->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <artifactId>apm-sdk-plugin</artifactId>
+        <groupId>org.apache.skywalking</groupId>
+        <version>9.3.0-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>solon-2.x-plugin</artifactId>
+    <packaging>jar</packaging>
+
+    <name>solon-plugin</name>
+    <url>http://maven.apache.org</url>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <apache-httpclient.version>4.3</apache-httpclient.version>
+        <junit.version>4.12</junit.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.noear</groupId>
+            <artifactId>solon-lib</artifactId>
+            <version>2.8.3</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>

apm-sniffer/apm-sdk-plugin/solon-2.x-plugin/src/main/java/org/apache/skywalking/apm/plugin/solon/FastPathMatcher.java

@@ -0,0 +1,171 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package org.apache.skywalking.apm.plugin.solon;
+
+public class FastPathMatcher {
+
+    public boolean match(String pattern, String path) {
+        return normalMatch(pattern, 0, path, 0);
+    }
+
+    private boolean normalMatch(String pat, int p, String str, int s) {
+        while (p < pat.length()) {
+            char pc = pat.charAt(p);
+            char sc = safeCharAt(str, s);
+
+            // Got * in pattern, enter the wildcard mode.
+            //            ↓        ↓
+            // pattern: a/*      a/*
+            //            ↓        ↓
+            // string:  a/bcd    a/
+            if (pc == '*') {
+                p++;
+                // Got * in pattern again, enter the multi-wildcard mode.
+                //             ↓        ↓
+                // pattern: a/**     a/**
+                //            ↓        ↓
+                // string:  a/bcd    a/
+                if (safeCharAt(pat, p) == '*') {
+                    p++;
+                    // Enter the multi-wildcard mode.
+                    //              ↓        ↓
+                    // pattern: a/**     a/**
+                    //            ↓        ↓
+                    // string:  a/bcd    a/
+                    return multiWildcardMatch(pat, p, str, s);
+                } else {
+                    // Enter the wildcard mode.
+                    //             ↓
+                    // pattern: a/*
+                    //            ↓
+                    // string:  a/bcd
+                    return wildcardMatch(pat, p, str, s);
+                }
+            }
+
+            // Matching ? for non-'/' char, or matching the same chars.
+            //            ↓        ↓       ↓
+            // pattern: a/?/c    a/b/c    a/b
+            //            ↓        ↓       ↓
+            // string:  a/b/c    a/b/d    a/d
+            if (pc == '?' && sc != 0 && sc != '/' || pc == sc) {
+                s++;
+                p++;
+                continue;
+            }
+
+            // Not matched.
+            //            ↓
+            // pattern: a/b
+            //            ↓
+            // string:  a/c
+            return false;
+        }
+
+        return s == str.length();
+    }
+
+    private boolean wildcardMatch(String pat, int p, String str, int s) {
+        char pc = safeCharAt(pat, p);
+
+        // End of pattern, check string only has zero or one '/' at end.
+        //             ↓        ↓
+        // pattern: a/*      a/*
+        //            ↓        ↓
+        // string:  a/bc/    a/bc
+        if (pc == 0) {
+            while (true) {
+                char sc = safeCharAt(str, s);
+                // No '/' found
+                if (sc == 0) return true;
+                // Check '/' is the last char of string
+                if (sc == '/') return s == str.length() - 1;
+                s++;
+            }
+        }
+
+        while (true) {
+            char sc = safeCharAt(str, s);
+
+            if (sc == '/') {
+                // Both of pattern and string '/' matched, exit wildcard mode.
+                //             ↓
+                // pattern: a/*/
+                //              ↓
+                // string:  a/bc/
+                if (pc == sc) {
+                    return normalMatch(pat, p + 1, str, s + 1);
+                }
+
+                // Not matched string in current path part.
+                //             ↓        ↓
+                // pattern: a/*      a/*d
+                //              ↓        ↓
+                // string:  a/bc/    a/bc/
+                return false;
+            }
+
+            // Try to enter normal mode, if not matched, increasing pointer of string and try again.
+            if (!normalMatch(pat, p, str, s)) {
+                // End of string, not matched.
+                if (s >= str.length()) {
+                    return false;
+                }
+
+                s++;
+                continue;
+            }
+
+            // Matched in next normal mode.
+            return true;
+        }
+    }
+
+    private boolean multiWildcardMatch(String pat, int p, String str, int s) {
+        switch (safeCharAt(pat, p)) {
+            // End of pattern, just return true quickly.
+            case 0: return true;
+            // Skip next '/' for pattern to match zero path part.
+            case '/': p++;
+        }
+
+        while (true) {
+            // Try to enter normal mode, if not matched, increasing pointer of string and try again.
+            if (!normalMatch(pat, p, str, s)) {
+                // End of string, not matched.
+                if (s >= str.length()) {
+                    return false;
+                }
+
+                s++;
+                continue;
+            }
+
+            return true;
+        }
+    }
+
+    private char safeCharAt(String value, int index) {
+        if (index >= value.length()) {
+            return 0;
+        }
+
+        return value.charAt(index);
+    }
+}

apm-sniffer/apm-sdk-plugin/solon-2.x-plugin/src/main/java/org/apache/skywalking/apm/plugin/solon/SolonActionExecuteInterceptor.java

@@ -0,0 +1,133 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package org.apache.skywalking.apm.plugin.solon;
+
+import lombok.extern.slf4j.Slf4j;
+import org.apache.skywalking.apm.agent.core.context.CarrierItem;
+import org.apache.skywalking.apm.agent.core.context.ContextCarrier;
+import org.apache.skywalking.apm.agent.core.context.ContextManager;
+import org.apache.skywalking.apm.agent.core.context.trace.AbstractSpan;
+import org.apache.skywalking.apm.agent.core.context.trace.SpanLayer;
+import org.apache.skywalking.apm.agent.core.plugin.interceptor.enhance.EnhancedInstance;
+import org.apache.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsAroundInterceptor;
+import org.apache.skywalking.apm.agent.core.plugin.interceptor.enhance.MethodInterceptResult;
+import org.apache.skywalking.apm.network.trace.component.ComponentsDefine;
+import org.apache.skywalking.apm.util.StringUtil;
+import org.noear.solon.Utils;
+import org.noear.solon.core.handle.Context;
+
+import java.lang.reflect.Method;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+@Slf4j
+public class SolonActionExecuteInterceptor implements InstanceMethodsAroundInterceptor {
+
+    private static FastPathMatcher pathMatcher = new FastPathMatcher();
+
+    private final Set<String> excludePaths = new HashSet<>();
+
+    private final Set<String> matchPaths = new HashSet<>();
+
+    public SolonActionExecuteInterceptor() {
+        String excluded = System.getProperty("skywalking.agent.solon.excluded", "");
+        if (Utils.isNotEmpty(excluded)) {
+            for (String path : excluded.split(",")) {
+                path = path.trim();
+                if (!path.isEmpty()) {
+                    if (!path.startsWith("/")) {
+                        path = "/" + path;
+                    }
+                    if (path.contains("*")) {
+                        matchPaths.add(path);
+                    } else {
+                        excludePaths.add(path);
+                    }
+                }
+            }
+        }
+    }
+
+    public boolean pathMatch(String path) {
+        for (String matchPath : matchPaths) {
+            if (pathMatcher.match(matchPath, path)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class<?>[] argumentsTypes,
+                             MethodInterceptResult result) throws Throwable {
+        Context ctx = (Context) allArguments[0];
+        if (excludePaths.contains(ctx.pathNew()) || pathMatch(ctx.pathNew())) {
+            return;
+        }
+        ContextCarrier contextCarrier = new ContextCarrier();
+        CarrierItem next = contextCarrier.items();
+        while (next.hasNext()) {
+            next = next.next();
+            next.setHeadValue(ctx.header(next.getHeadKey()));
+        }
+        String operationName = "Solon:" + ctx.method() + ":" + ctx.path();
+        AbstractSpan span = ContextManager.createEntrySpan(operationName, contextCarrier);
+        span.setComponent(ComponentsDefine.SOLON_MVC);
+        SpanLayer.asHttp(span);
+        span.tag("http.method", ctx.method());
+        span.tag("http.path", ctx.path());
+        span.tag("framework", "solon");
+        for (Map.Entry<String, String> stringStringEntry : ctx.headerMap().entrySet()) {
+            span.tag(stringStringEntry.getKey(), stringStringEntry.getValue());
+        }
+        String body = ctx.body();
+        if (StringUtil.isNotBlank(body)) {
+            if (body.length() > 1024) {
+                body = body.substring(0, 1024);
+            }
+            span.tag("http.body", body);
+        }
+        String param = ctx.paramMap().toString();
+        if (param.length() > 1024) {
+            param = param.substring(0, 1024);
+        }
+        span.tag("http.param", param);
+    }
+
+    @Override
+    public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class<?>[] argumentsTypes,
+                              Object ret) {
+        Context ctx = (Context) allArguments[0];
+        if (excludePaths.contains(ctx.pathNew()) || pathMatch(ctx.pathNew())) {
+            return ret;
+        }
+
+        ContextManager.activeSpan().tag("http.status_code", String.valueOf(ctx.status()));
+        ContextManager.stopSpan();
+        return ret;
+    }
+
+    @Override
+    public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments,
+                                      Class<?>[] argumentsTypes, Throwable t) {
+        AbstractSpan activeSpan = ContextManager.activeSpan();
+        activeSpan.log(t);
+    }
+}