WIP refactor in MailboxMetrics

4 files changed, 84 insertions, 44 deletions

diff --git a/src/main/resources/META-INF/aop.xml b/src/main/resources/META-INF/aop.xml
index b5e50721..b5e78683 100644
--- a/src/main/resources/META-INF/aop.xml
+++ b/src/main/resources/META-INF/aop.xml
@@ -7,9 +7,9 @@
 
     <aspects>
         <aspect name="akka.ActorSystemAspect"/>
-        <aspect name="akka.MailboxAspect"/>
+        <!--<aspect name="akka.MailboxAspect"/>-->
         <aspect name="akka.PoolMonitorAspect"/>
-        <aspect name="akka.ActorAspect"/>
+        <!--<aspect name="akka.ActorAspect"/>-->
 
         <include within="*"/>
         <exclude within="javax.*"/>
diff --git a/src/main/scala/akka/MailboxMetrics.scala b/src/main/scala/akka/MailboxMetrics.scala
new file mode 100644
index 00000000..27188a8c
--- /dev/null
+++ b/src/main/scala/akka/MailboxMetrics.scala
@@ -0,0 +1,36 @@
+package akka
+
+import akka.dispatch.Mailbox
+import akka.actor.Actor
+import com.newrelic.api.agent.NewRelic
+
+case class MailboxMetrics(mailboxes:Map[String,Mailbox])
+
+
+object  MailboxMetrics {
+  def apply(mailboxes: List[Mailbox]) = {
+    new MailboxMetrics(mailboxes.take(mailboxes.length - 1).map{m => (m.actor.self.path.toString -> m)}.toMap) //TODO:research why collect an ActorSystemImpl
+  }
+
+  def toMap(mb: Mailbox):Map[String,Int] = Map[String,Int](
+    "NumberOfMessages" -> mb.numberOfMessages,
+    "MailboxDispatcherThroughput" -> mb.dispatcher.throughput,
+    "SuspendCount" -> mb.suspendCount
+  )
+}
+
+class MailboxSenderMetricsActor(mailboxes: List[Mailbox]) extends Actor {
+  def receive = {
+    case "SendMailboxMetrics" => {
+        val mbm = MailboxMetrics(mailboxes)
+        mbm.mailboxes.map { case(actorName, mb) => {
+          println(s"Sending metrics to Newrelic MailBoxMonitor -> ${actorName}")
+          NewRelic.recordMetric(s"${actorName}:Mailbox:NumberOfMessages", mb.numberOfMessages)
+          NewRelic.recordMetric(s"${actorName}:Mailbox:MailboxDispatcherThroughput", mb.dispatcher.throughput)
+          NewRelic.recordMetric(s"${actorName}:Mailbox:SuspendCount", mb.suspendCount)
+        }
+      }
+    }
+  }
+}
+
diff --git a/src/main/scala/akka/PoolMetrics.scala b/src/main/scala/akka/PoolMetrics.scala
new file mode 100644
index 00000000..07fbfff7
--- /dev/null
+++ b/src/main/scala/akka/PoolMetrics.scala
@@ -0,0 +1,32 @@
+package akka
+
+import scala.concurrent.forkjoin.ForkJoinPool
+import akka.actor.Actor
+import com.newrelic.api.agent.NewRelic
+
+case class PoolMetrics(poolName:String, data:Map[String,Int])
+
+object PoolMetrics {
+  def apply(pool: ForkJoinPool) = new PoolMetrics(pool.getClass.getSimpleName, toMap(pool))
+
+  def toMap(pool: scala.concurrent.forkjoin.ForkJoinPool):Map[String,Int] = Map[String,Int](
+    "ActiveThreadCount" -> pool.getActiveThreadCount,
+    "Parallelism" -> pool.getParallelism,
+    "PoolSize" -> pool.getPoolSize,
+    "QueuedSubmissionCount" -> pool.getQueuedSubmissionCount,
+    "StealCount" -> pool.getStealCount.toInt,
+    "QueuedTaskCount" -> pool.getQueuedTaskCount.toInt,
+    "RunningThreadCount" -> pool.getRunningThreadCount
+  )
+}
+
+class PoolMetricsActorSender(forkJoinPool:ForkJoinPool) extends Actor {
+  def receive = {
+    case "SendPoolMetrics" => {
+      val pool = PoolMetrics(forkJoinPool)
+      println(s"Sending Metrics to NewRelic -> ${pool}")
+      pool.data.map{case(k,v) => NewRelic.recordMetric(s"${pool.poolName}:${k}",v)}
+    }
+  }
+}
+
diff --git a/src/main/scala/akka/Tracer.scala b/src/main/scala/akka/Tracer.scala
index 60906dae..bb290960 100644
--- a/src/main/scala/akka/Tracer.scala
+++ b/src/main/scala/akka/Tracer.scala
@@ -1,11 +1,11 @@
 package akka
 
-import actor.{Props, Actor, ActorSystemImpl}
+import actor.{Props, ActorSystemImpl}
 import scala.concurrent.forkjoin.ForkJoinPool
 import scala.concurrent.duration._
-import com.newrelic.api.agent.NewRelic
 import akka.dispatch.Mailbox
 import scala._
+import com.newrelic.api.agent.NewRelic
 
 object Tracer {
   protected[this] var mailboxes:List[Mailbox] = List.empty
@@ -18,54 +18,26 @@ object Tracer {
 
   def start():Unit ={
     implicit val dispatcher = tracerActorSystem.dispatcher
-    val metricsActor = tracerActorSystem.actorOf(Props[MetricsActor], "MetricsActor")
-
-    tracerActorSystem.scheduler.schedule(10 seconds, 6 second, metricsActor, PoolMetrics(forkJoinPool))
-    tracerActorSystem.scheduler.schedule(10 seconds, 6 second, metricsActor, MailboxMetrics(mailboxes))
-  }
-}
+    val poolMetricsActorSender = tracerActorSystem.actorOf(Props(new PoolMetricsActorSender(forkJoinPool)), "PoolMetricsActorSender")
+    //val mailboxMetricsActorSender = tracerActorSystem.actorOf(Props(new MailboxSenderMetricsActor(mailboxes)), "MailboxMetricsActorSender")
 
-case class PoolMetrics(poolName:String, data:Map[String,Int])
-case class MailboxMetrics(mailboxes:Map[String,Mailbox])
+    tracerActorSystem.scheduler.schedule(10 seconds, 6 second, poolMetricsActorSender, "SendPoolMetrics")
 
-
-object PoolMetrics {
-  def apply(pool: ForkJoinPool) = new PoolMetrics(pool.getClass.getSimpleName, toMap(pool))
-
-  def toMap(pool: scala.concurrent.forkjoin.ForkJoinPool):Map[String,Int] = Map[String,Int](
-    "ActiveThreadCount" -> pool.getActiveThreadCount,
-    "Parallelism" -> pool.getParallelism,
-    "PoolSize" -> pool.getPoolSize,
-    "QueuedSubmissionCount" -> pool.getQueuedSubmissionCount,
-    "StealCount" -> pool.getStealCount.toInt,
-    "QueuedTaskCount" -> pool.getQueuedTaskCount.toInt,
-    "RunningThreadCount" -> pool.getRunningThreadCount
-  )
-}
-
-object  MailboxMetrics {
-  def apply(mailboxes: List[Mailbox]) = {
-    new MailboxMetrics(mailboxes.take(mailboxes.length - 1).map{m => (m.actor.self.path.toString -> m)}.toMap) //TODO:reseach why collect an ActorSystemImpl
-  }
-}
-
-class MetricsActor extends Actor {
-    def receive = {
-
-      case poolMetrics:PoolMetrics => {
-        println(poolMetrics)
-        poolMetrics.data.map{case(k,v) => NewRelic.recordMetric(s"${poolMetrics.poolName}:${k}",v)}
-      }
-      case mailboxMetrics:MailboxMetrics => {
-        mailboxMetrics.mailboxes.map { case(actorName,mb) =>
+    tracerActorSystem.scheduler.schedule(10 seconds, 6 second, new Runnable {
+      def run() {
+        val mbm = MailboxMetrics(mailboxes)
+        mbm.mailboxes.map { case(actorName,mb) => {
           println(s"Sending metrics to Newrelic MailBoxMonitor -> ${actorName}")
-
           NewRelic.recordMetric(s"${actorName}:Mailbox:NumberOfMessages",mb.numberOfMessages)
           NewRelic.recordMetric(s"${actorName}:Mailbox:MailboxDispatcherThroughput",mb.dispatcher.throughput)
 
           NewRelic.addCustomParameter(s"${actorName}:Mailbox:Status", mb.hasMessages.toString)
           NewRelic.addCustomParameter(s"${actorName}:Mailbox:HasMessages", mb.hasMessages.toString)
+      }
         }
       }
-    }
+    })
+
+  }
+    //tracerActorSystem.scheduler.schedule(10 seconds, 6 second, mailboxMetricsActorSender, "SendMailboxMetrics")
 }
\ No newline at end of file