Add agent arguments to be passed to the java agent. Fixes #3

Author: bantonsson

README.md

@@ -60,4 +60,12 @@ Note that in this case, the agent dependency is actually added under the `provid
 
 If the *compile* scope is not enabled, then the agent dependency is put under a special `javaagent` configuration so that it doesn't appear as a regular library dependency or on build classpaths.
 
+## Agent arguments
+
+A Java agent can have an extra argument string added to it that is provided to the `premain` method in the agent. To add an argument string simply provide it to the `JavaAgent` constructor.
+
+```scala
+javaAgents += JavaAgent("com.example" % "agent" % "1.2.3" % "compile;test", arguments = "java_agent_argument_string")
+```
+
 [sbt-native-packager]: https://github.com/sbt/sbt-native-packager

maxwell/src/main/java/maxwell/Maxwell.java

@@ -1,9 +1,15 @@
 package maxwell;
 
 import java.lang.instrument.Instrumentation;
+import java.util.regex.Pattern;
 
 public class Maxwell {
     public static void premain(String agentArgs, Instrumentation instrumentation) {
-        System.out.println("Agent 86");
+        String[] output = new String[] { "Agent 86" };
+        if (agentArgs != null) {
+            output = agentArgs.split(Pattern.quote(";"));
+        }
+        for (String string: output)
+            System.out.println(string);
     }
 }

src/main/scala/com/lightbend/sbt/javaagent/JavaAgent.scala

@@ -27,7 +27,7 @@ object JavaAgent extends AutoPlugin {
 
   case class AgentScope(compile: Boolean = false, test: Boolean = false, run: Boolean = false, dist: Boolean = true)
 
-  case class AgentModule(name: String, module: ModuleID, scope: AgentScope)
+  case class AgentModule(name: String, module: ModuleID, scope: AgentScope, arguments: String)
 
   case class ResolvedAgent(agent: AgentModule, artifact: File)
 
@@ -40,8 +40,9 @@ object JavaAgent extends AutoPlugin {
    * Create an agent module from a module dependency.
    * Scope is also derived from the given module configuration.
    */
-  def apply(module: ModuleID, name: String = null, scope: AgentScope = AgentScope()): AgentModule = {
+  def apply(module: ModuleID, name: String = null, scope: AgentScope = AgentScope(), arguments: String = null): AgentModule = {
     val agentName = Option(name).getOrElse(module.name)
+    val agentArguments = Option(arguments).map("=" + _).getOrElse("")
     val confs = module.configurations.toSeq.flatMap(_.split(";"))
     val inCompile = scope.compile || confs.contains(Compile.name) || confs.contains(Provided.name)
     val inRun = scope.run || inCompile || confs.contains(Runtime.name)
@@ -50,7 +51,7 @@ object JavaAgent extends AutoPlugin {
     val configuration = if (inCompile) Provided else AgentConfig
     val reconfiguredModule = module.copy(configurations = Some(configuration.name))
     val configuredScope = AgentScope(compile = inCompile, test = inTest, run = inRun, dist = inDist)
-    AgentModule(agentName, reconfiguredModule, configuredScope)
+    AgentModule(agentName, reconfiguredModule, configuredScope, agentArguments)
   }
 
   override def requires = plugins.JvmPlugin
@@ -87,8 +88,8 @@ object JavaAgent extends AutoPlugin {
   }
 
   private def agentOptions(enabled: ResolvedAgent => Boolean) = Def.task[Seq[String]] {
-    resolvedJavaAgents.value filter enabled map { agent =>
-      "-javaagent:" + agent.artifact.absolutePath
+    resolvedJavaAgents.value filter enabled map { resolved =>
+      "-javaagent:" + resolved.artifact.absolutePath + resolved.agent.arguments
     }
   }
 

src/main/scala/com/lightbend/sbt/javaagent/JavaAgentPackaging.scala

@@ -21,19 +21,21 @@ object JavaAgentPackaging extends AutoPlugin {
   override def requires = JavaAgent && PluginRef("com.typesafe.sbt.packager.archetypes.JavaAppPackaging")
 
   override def projectSettings = Seq(
-    mappings in Universal ++= agentMappings.value,
+    mappings in Universal ++= agentMappings.value.map(m => m._1 -> m._2),
     bashScriptExtraDefines ++= agentScriptOptions.value
   )
 
-  private def agentMappings = Def.task[Seq[(File, String)]] {
+  private def agentMappings = Def.task[Seq[(File, String, String)]] {
     resolvedJavaAgents.value filter (_.agent.scope.dist) map { resolved =>
-      resolved.artifact -> (Project.normalizeModuleID(resolved.agent.name) + File.separator + resolved.artifact.name)
+      (resolved.artifact,
+        Project.normalizeModuleID(resolved.agent.name) + File.separator + resolved.artifact.name,
+        resolved.agent.arguments)
     }
   }
 
   private def agentScriptOptions = Def.task[Seq[String]] {
     agentMappings.value map {
-      case (_, path) => s"""addJava "-javaagent:$${app_home}/../${normalizePath(path)}" """
+      case (_, path, arguments) => s"""addJava "-javaagent:$${app_home}/../${normalizePath(path)}$arguments" """
     }
   }
 

src/sbt-test/agent/arguments/build.sbt

@@ -0,0 +1,4 @@
+lazy val agentOptions = project in file(".") enablePlugins (JavaAgent, JavaAppPackaging)
+
+javaAgents += JavaAgent(module = "sbt.javaagent.test" % "maxwell" % sys.props("project.version") % "dist;test",
+  arguments = "Get_Smart;Agent_99")

src/sbt-test/agent/arguments/project/plugins.sbt

@@ -0,0 +1,2 @@
+addSbtPlugin("com.lightbend.sbt" % "sbt-javaagent"       % sys.props("project.version"))
+addSbtPlugin("com.typesafe.sbt"  % "sbt-native-packager" % sys.props("packager.version"))

src/sbt-test/agent/arguments/src/main/scala/Main.scala

@@ -0,0 +1 @@
+object Main extends App

src/sbt-test/agent/arguments/test

@@ -0,0 +1,2 @@
+> stage
+> check

src/sbt-test/agent/arguments/test.sbt

@@ -0,0 +1,40 @@
+TaskKey[Unit]("check") := {
+  assert(
+    (fork in Test).value,
+    "fork in Test is not enabled"
+  )
+
+  assert(
+    (javaOptions in Test).value exists (s => s.contains("-javaagent:") && s.contains("maxwell")),
+    "javaOptions in Test do not contain 'maxwell' agent"
+  )
+
+  assert(
+    (javaOptions in Test).value exists (s => s.contains("-javaagent:") && s.contains("maxwell") && s.contains("=Get_Smart;Agent_99")),
+    "javaOptions in Test do not contain 'Get_Smart;Agent_99' agent arguments"
+  )
+
+  assert(
+    (mappings in Universal).value exists { case (file, path) => path == "maxwell/maxwell.jar" },
+    "dist mappings do not include 'maxwell/maxwell.jar'"
+  )
+
+  val output = ((stagingDirectory in Universal).value / "bin" / packageName.value).absolutePath.!!
+
+  assert(
+    !(output contains "Agent 86"),
+    "output includes 'Agent 86'"
+  )
+  assert(
+    !(output contains ";"),
+    "output includes ';'"
+  )
+  assert(
+    output contains "Get_Smart",
+    "output does not include 'Get_Smart'"
+  )
+  assert(
+    output contains "Agent_99",
+    "output does not include 'Agent_99'"
+  )
+}