Add Scala concurrent plugin

CHANGELOG.asciidoc

@@ -35,6 +35,7 @@ The latter uses https://github.com/elastic/ecs-logging-java[ecs-logging-java] to
 * Exposing <<config-classes-excluded-from-instrumentation>> config - {pull}1187[#1187]
 * Add support for naming transactions based on Grails controllers. Supports Grails 3+ - {pull}1171[#1171]
 * Add support for the Apache/Alibaba Dubbo RPC framework
+* Add experimental support for Scala Futures
 
 [float]
 ===== Bug fixes

apm-agent-plugins/apm-scala-concurrent-plugin/pom.xml

@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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-agent-plugins</artifactId>
+        <groupId>co.elastic.apm</groupId>
+        <version>1.16.1-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>apm-scala-concurrent-plugin</artifactId>
+    <name>${project.groupId}:${project.artifactId}</name>
+
+    <properties>
+        <apm-agent-parent.base.dir>${project.basedir}/../..</apm-agent-parent.base.dir>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>${project.groupId}</groupId>
+            <artifactId>apm-java-concurrent-plugin</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.scalameta</groupId>
+            <artifactId>munit_2.13</artifactId>
+            <version>0.7.2</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <testSourceDirectory>src/test/scala</testSourceDirectory>
+        <plugins>
+            <plugin>
+                <groupId>net.alchim31.maven</groupId>
+                <artifactId>scala-maven-plugin</artifactId>
+                <version>4.3.1</version>
+                <configuration>
+                    <scalaVersion>2.13.2</scalaVersion>
+                </configuration>
+                <executions>
+                    <execution>
+                        <id>scala-test-compile</id>
+                        <phase>process-test-resources</phase>
+                        <goals>
+                            <goal>testCompile</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>

apm-agent-plugins/apm-scala-concurrent-plugin/src/main/java/co/elastic/apm/agent/scala/concurrent/FutureInstrumentation.java

@@ -0,0 +1,114 @@
+/*-
+ * #%L
+ * Elastic APM Java agent
+ * %%
+ * Copyright (C) 2018 - 2020 Elastic and contributors
+ * %%
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. 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.
+ * #L%
+ */
+package co.elastic.apm.agent.scala.concurrent;
+
+import co.elastic.apm.agent.bci.ElasticApmInstrumentation;
+import co.elastic.apm.agent.bci.VisibleForAdvice;
+import co.elastic.apm.agent.impl.transaction.AbstractSpan;
+import com.blogspot.mydailyjava.weaklockfree.WeakConcurrentMap;
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.description.method.MethodDescription;
+import net.bytebuddy.description.type.TypeDescription;
+import net.bytebuddy.matcher.ElementMatcher;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.Arrays;
+import java.util.Collection;
+
+import static net.bytebuddy.matcher.ElementMatchers.*;
+
+public abstract class FutureInstrumentation extends ElasticApmInstrumentation {
+
+    @VisibleForAdvice
+    @SuppressWarnings("WeakerAccess")
+    public static final WeakConcurrentMap<Object, AbstractSpan<?>> promisesToContext =
+        new WeakConcurrentMap.WithInlinedExpunction<>();
+
+    @Nonnull
+    @Override
+    public Collection<String> getInstrumentationGroupNames() {
+        return Arrays.asList("scala-future", "experimental");
+    }
+
+    public static class ConstructorInstrumentation extends FutureInstrumentation {
+
+        @Override
+        public ElementMatcher<? super TypeDescription> getTypeMatcher() {
+            return named("scala.concurrent.impl.Promise$Transformation");
+        }
+
+        @Override
+        public ElementMatcher<? super MethodDescription> getMethodMatcher() {
+            return isConstructor();
+        }
+
+        @Advice.OnMethodExit(suppress = Throwable.class)
+        public static void onExit(@Advice.This Object thiz) {
+            final AbstractSpan<?> context = getActive();
+            if (context != null) {
+                promisesToContext.put(thiz, context);
+                // this span might be ended before the Promise$Transformation#run method starts
+                // we have to avoid that this span gets recycled, even in the above mentioned case
+                context.incrementReferences();
+            }
+        }
+
+    }
+
+    public static class RunInstrumentation extends FutureInstrumentation {
+
+        @Override
+        public ElementMatcher<? super TypeDescription> getTypeMatcher() {
+            return named("scala.concurrent.impl.Promise$Transformation");
+        }
+
+        @Override
+        public ElementMatcher<? super MethodDescription> getMethodMatcher() {
+            return named("run").and(returns(void.class));
+        }
+
+        @VisibleForAdvice
+        @Advice.OnMethodEnter(suppress = Throwable.class)
+        public static void onEnter(@Advice.This Object thiz, @Nullable @Advice.Local("context") AbstractSpan<?> context) {
+            context = promisesToContext.remove(thiz);
+            if (tracer != null && context != null) {
+                tracer.activate(context);
+                // decrements the reference we incremented to avoid that the parent context gets recycled before the promise is run
+                // because we have activated it, we can be sure it doesn't get recycled until we deactivate in the OnMethodExit advice
+                context.decrementReferences();
+            }
+        }
+
+        @Advice.OnMethodExit(suppress = Throwable.class)
+        public static void onExit(@Nullable @Advice.Local("context") AbstractSpan<?> context) {
+            if (tracer != null && context != null) {
+                tracer.deactivate(context);
+            }
+        }
+
+    }
+
+}

apm-agent-plugins/apm-scala-concurrent-plugin/src/main/resources/META-INF/services/co.elastic.apm.agent.bci.ElasticApmInstrumentation

@@ -0,0 +1,2 @@
+co.elastic.apm.agent.scala.concurrent.FutureInstrumentation$ConstructorInstrumentation
+co.elastic.apm.agent.scala.concurrent.FutureInstrumentation$RunInstrumentation