Shahzad Bhatti Welcome to my ramblings and rants!

I had fun at OSCON last year, so I decided to go back this year. It’s incredible experience being part of hundreds of developers (more than 2500), who are excited about open source and upcoming technogolies. Though, there were a number of tracks, but I was mainly interested in Mobile Computing, Cloud Computing, No-SQL, and Scala. There were also interesting sessions on Emerging Languages and Hardware Hacking with Arduino, but I didn’t get chance to attend them.

Tutorials Day One

I arrived in Portalnd on Sunday night and the first session I attended on Monday morning was on Android. I saw fair number of Android phones at the conference and people were excited about Android. There was a lot of bashing of Apple, but I won’t get into it. Here are some of the highlights from the Android session:

Android for Java Developers

Android is a specially designed O/S based on Linux that uses a number of open source libraries and custom framework for building mobile applications. It even comes with a command line tool adb that opens shell directly on the device or emulator. Though, Android applications are written in Java but the byte-codes are converted into Dalvik instruction sets (.dex files). Dalvik is a register based Java VM as opposed to Sun’s stack based and uses JavaSE minus Swing/AWT APIs. You use Dalvik generated executable and resources (images, audio, configurations, etc.) to build the application file (APK), which is then signed by self-generated certificate. The best part of Android development is their deployment, which is an order of magnitude easier compare to Apple iOS.

Android SDK

Before developing, you would need to download the Eclipse IDE, Android SDK and then install Eclipse plugin from https://dl-ssl.google.com/android/eclipse/.

Creating Android Device

One of the downside of Android is variations of the capabilities of all Android devices, however you don’t need to own all variations. All you need is to create Android device by giving name, target version, SD card, skin and other hardware limitations. Android comes with emulator as opposed to simulator with iPhone SDK and follows hardware much more closely. On the downside, it takes a long time to start the Android emulator, but on the upside you can emulate call, SMS, and launch multiple emulators, which can other emulators. Note, the android device file definition goes into ~/.android/avd directory.

Hello World

You can create a new project and specify the build target, application name, package name, and main activity class. An activity class represents a controller class, which you define for each screen. Android uses UI to generate layout file (R file). If your application need resources such as images and property files, you store them in res directory. You can also create resource files for storing strings to make your application easily localized for various languages.

Activities

Activities represent screens and are managed by the activity managers. The activity can be in one of five states: starting, running, paused, stopped, and destroyed. The Activity class defines callback methods such as onCreate, onStart, onRestoreInstanceState, and onResume when the state changes.

Intent

Intent represents events or actions, which can be explicit or implicit.

Services

One of the key advantage of Android has been its support of multi-tasking and you can have a background processing using services. Services also have lifecycle, but simpler than activities.

Content Providers

Content providers allow sharing data between applications such as contacts, mediastore, settings, etc.

Broadcast Receivers

These allow pub-sub based mechanism for system events such as SMS messages.

Architecture of Android applications

Here are some of the tips that Marko Gargenta gave when designing application:

• Isolate I/O operations such as network or disk operations into separate tasks or background services, which either use notification or database to communicate with interactive application. For example, in his sample twitter application, he used background service to poll tweets and stored them to the database. The activities then polled tweets from the database and also subscribed to the notification when new tweet arrives.
• Use layout for screen design as it is more declarative and separate text values from the layout and use string resources.
• Due to the variations of the Android devices, use layout weight and density intensity pixel (dp or sp) instead of fixed pixels (px) for components.
• Android SDK provides GUI tool for designing layout and you will need to bind the UI components back to the activity classes, so use consistent naming convention for both layout file and the activity file, e.g.

     public class Twitter extends Activity {
       EditText editTweet;
       Button buttonUpdate;
       public void onCreate(...) {
         editTweet = (EditText) findViewById(R.id.editTweet);
         editButton = (Button) findViewById(R.id.editButton);
         buttonUpdate.setOnClickListener(this)
           String tweet = editTweet.getText().toString();
         }
       }
     }
   

Adapters

Android allows easily access large datasets as arrays that can be displayed on the screen.

Logging

Android uses custom libc and Java for Logging and you can add logging as:

   Log.debug("ClassName", "button clicked");
 

You can use “adb logcat” command to view logs, e.g. “adb logcat Twitter:* *:S”

Security Permissions

Any permissions that user need must be defined in the manifest file.

Advanced components

Android comes with a number of advanced components such as Map, Menus, Graphics, Animations, Multimedia, Preferences, Sqlite databases, etc.

Cloud to Device Push

This is a new service similar to iPhone push notification.

Debugging

Marko suggested use of Eclipse debugger, logcat, hierarchy viewer and traceview for debugging.

For more information on Android session, Download the slides.

The Seductions of Scala

For the second half of the day, I attended Dean Wampler’s session on Scala. I have been long interested in Scala and have done a little development on my own. As OSCON offered a lot of sessions on Scala, I took the opportunity to learn more on Scala. Dean highlighted concurrency, concise code, and correctness, better object model as major benefits of Scala.

Introduction

Scala comes with a number of features for concise code such as implicit type conversion, properties with uniform access principle and optional semicolons and paranthesis when function arguments are one or empty. Scala allows objects to act as function using apply method, e.g.

   class Logger(val level: Level) {
         def apply(message: String) = {
                 log(level, message)
         }
   }
 
 val error = new Logger(ERROR) ...
 error("Network error.")
 

Also, Scala treats primitive types as objects, but are comiled down as primitivies. Scala also treats functions as objects, e.g. you can create list or map without new

 val list = List(1, 2, 3, 4, 5)
 val map = Map("name" -> "Dean", "age" -> 39)
 

Above list syntax is same as 1::2::3::4::5::Nil. Scala also allows any symbol for function name so you can define functions that look like operator overloading. Scala uses infix operator notation, for example, following two expressions are equivalent:

 "hello" + "world" 
 "hello".+("world")
 

Scala gives you higher level operations such as map, filter, fold/reduce, e.g.

 val list = "a" :: "b" :: Nil
 list map {
         s => s.toUpperCase
 }
 

Generics

Martin Ordesky added limited support of Generics in Java, but he added fully functional generics support in Scala, e.g.

 class List[A] { ...
 def map[B](f: A => B): List[B]
 ... 
 }
 

Traits

One of nice feature of Scala is its support of Traits, which are interfaces with implementation and are similar to Ruby mixins. Here is an example:

 trait Logger { def log(level: Level,
 message: String) = { Log.log(level, message)
 } }
 val dean = new Person(...) extends Logger
 dean.log(ERROR, "Bozo alert!!")
 

Scala also defines traits for functions to convert them into objects, e.g.

 trait Function1[A,R] extends AnyRef {
 def apply(a:A): R
 ... }
 

User-defined factory methods

You can define functions as factory-methods to instantiate objects, e.g.

  val persons = Map("dean" -> deanPerson, "alex", -> alexPerson)
 

DSL

Scala offers powerful semantics to define internal DSLs, e.g. you can create your own controls, e.g.

 import java.io._ object Loop {
 {...}
 }
 def loop(file: File, f: (Int,String) => Unit) =
 ...
 loop (new File("...")) { (n, line) => ...
 }
 

Options as alternative to Null

Scala avoid NullPointerExceptions by wrapping nulls into options, e.g.

 abstract class Option[T] {...} case class Some[T](t: T)
 extends Option[T] {...} case object None
 extends Option[Nothing] {...}
 

Case Classes

Case classes provide succint syntax for creatng Javabeans.

For comprehensions

Scala provides for comprehensions, which are similar to Python generators, e.g.

 val l = List( Some("a"), None, Some("b"), None, Some("c"))
 for (Some(s) <- l) yield s
 

Actors

Scala provides Actor based concurrency similar to Erlang, though there are multiple implementations and Akka seems to provide better implementation than what comes with Scala. Here is an example:

 case class Point(
 x: Double, y: Double)
 abstract class Shape { def draw()
 }
 ....
 package shapes import scala.actors._, Actor._ object ShapeDrawingActor
 extends Actor { def act() {
 loop { receive {
   case s:Shape =>
   s.draw()
 ... }
 } }
 }
 

Tutorials Day Two

On day two, I attended all-day Scala summit, which covered various topics for practical Scala.

Why Scala?

The summit started with session on "Why Scala?" by Alex Payne and Dean Wampler. Dean repeated some of same concepts from Monday's session on Scala's conciseness, concurrency, correctness, infix operator, type inference, case classes, etc. Dean then gave some examples of actors using Akka, where he calls multiple services using actors and then gather the results, e.g.

 val futures = for { s   <- services
 server <- allServersFor(s) }
 yield (server !!! HeartBeat)
 Futures.awaitAll(futures) val results = for {
 future <- futures
 result <- future.result } yield result val all = results reduceLeft(
 (r1, r2) => r1 merge r2 ) compact(render(all))
 }}
 

Akka: Simpler Scalability, Fault-Tolerance, Concurrency & Remoting through Actors

Jonas Bonér then gave brief overview of Akka, which provides a number ofabstractions for concurrency such as actors, STM, and agents. Jonas gave introduction to actors, which provide concurrency based on message-passing, shared-nothing, and mailbox. In Akka, actors can be thread based or event based, where event based actors are very light-weight and you can create millions of them (each actor takes about 600 bytes as opposed to 300 bytes in Erlang).

factory-methods

Akka uses factory-methods to hide type of actors, e.g.

 val counter = actorOf[Counter]  // counter is ActorRef
 actor.start
 actor.stop
 
 

Jonas suggested use of actorOf as opposed to "new Counter" syntax as it avoids calling methods on the objects directly. Akka uses !, !! and !!! notations to send messages, where ! is just fire and forget, !! collects results using Futures and !!! returns Future, e..g

 counter ! Tick // send message -- fire-forget
 val result  = (actor !! Message).as[String] // uses Future under the hood with timeout
 val resultOption = actor !! Message
 val result = resultOption.getOrElse(defaultResult)
 val result = resultOption.getOrElse(throw new Exception("time out"))
 val future = actor !!! Message
 future.await
 val result = future.get
 
 Futures.awaitOne(List(fut1, ..))
 Futures.awaitAll(List(fut1,))
 
 

You use self.reply to reply back to the sender and access sender using self.sender or self.senderFuture.

Immutable Messages

In order to keep actors free of side effects, messages must be immutable using case classes, tuples or lists, e.g.

 - case class Register(user: User)
 - actor ! Register(user)
 - actor ! (username, password)
 - actor ! List("xxx", "yy")
 

Dispatchers

Akka comes with a number of dispatches such as event based, thread based, reactor, etc. See Dispatchers class for more information.

Queues

Akka also comes with various queue types such as unbounded LinkedBlockingQueue, bounded LinkedBlockingQueue, etc.

ActorRegistry

ActorRegistry provides lookup methods for actors such as ActorRegistry.actorsFor.

Fault tolerance

Akka borrows concepts of hierarchy of supervisors for managing actors or processes from Erlang. Erlang's philosophy for fault tolerance is let it crash and the supervisor automatically starts failed process or group of processes. You use link(actor), unlink(actor), startLink(actor) to connect actors with supervisors and trap events using trapExit = List(classOf[ServiceException], classOf[PersistentException]), e.g.

 class Supervisor extends Actor {
   import self._
   trapExit = List(classOf[Throwable])
 }
 
 class FaultTolerantService extends Actor
   override def preRestart
   override def postRestart
 

Remote Actors

You can start a node, which is remotely accessible using:

 RemoteNode.start("localhost", 9999)
 spawnLinkRemote[MyActor]("darkstar", 9999)
 
 RemoteNode.register("service:id", )
 

STM, Transactors, Modules, Camel, Storage

We ran out of time for the rest of contents, but you can read more from the Slides.

Simple Build Tool

Next, Mark Harrah presented SBT, which everyone raved at the summit. SBT uses Scala based DSL for writing build scripts and internally uses Ivy for managing dependencies. You can create a new project by creating a new directory and typing sbt. You can set various properties in sbt shell such as target version, e.g.

 set build.scala.versions 2.80
 reload
 

You can easily create custom tasks in sbt by extending DefaultProject, e.g.

 import sbt._
 class MyProject(info: ProjectInfo) extends DefaultProject(info) {
   lazy val hi = task { println("Hi"); None}
   lazy val goodbye = task { println("Bye"); None} dependsOn(hi)
 }
 

You can also target tasks for just test using

 import sbt._
 class MyProject(info: ProjectInfo) extends DefaultProject(info) {
   val sc = "org.scala-tools.testing" %% "scalacheck" % "1.7" % "test"
 }
 OR
 import sbt._
 class MyProject(info: ProjectInfo) extends DefaultProject(info) {
   val sc = "org.scala-tools.sbt" %% "launcher-interface" % "0.74"
   val tt = "org.scala-tools.sbt" %% "launcher-interface" % "0.74" % "test"
 }
 

You can define main application as follows:

 import xsbti._
 class HW extends AppMain {
   def run(config: AppConfiguration): MainResult = {config.arguments foreach println; new Exit {def code = 0}}
 }
 

You generate executable jar by typing publish-local in sbt shell. You can define plugins as follows:

 class Plugins(inf: ProjectInfo) extends PluginDefinition(info) {
 val android = "org.scala-tools.sbt" % "sbt-android-plugin" % "0.5.0"
 }
 

Finally, sbt allows you to create processors, which behave like scaffolding in Rails, e.g.

 import xsbti._
 import processor._
 class HW extends BasicProcessor {
   def apply(project: Project, args: String) {
     import project._
         val contents = "This is " + name + "" + version + "\n" + args + "\n"
         FileUtilities.write(info.projectPath / "README" asFile, contents, log)
   }
 }
 

When you type publish, it will create README file for the project. That was pretty much the introduction to the sbt.

Specs & Scala, Tips and Tricks for a Friendly DSL Syntax

Eric Torreborre talked about Spec, which a BDD based testing tool for Scala. Spec provides support for BDD, Structures, Matchers, ScalaCheck, Mocks, Runners and databases. You use matchers to compare strings or XML contents, e.g.

 class Reverse2Spec extends  Specficiation {
   reverse("") must_== ""
 ...
 
 

You can restrict scope by defining tag method, e.g.

 class Example(des : String) {
   def in(arg: Any) = expectations
   def tag(t : String) = this
 }
 

Scala DSL

Spec uses a number of tricks for simplifying the syntax such as implicit parameters, operators, lazy evaluation.

 "With a 3 tests ok" in {
   prop 
 }
 //Some paraemeters can be implicit
 implicit val defaultparams = new Params
 
 "this should not explode" in {
   error("boom")
 }
 def in(e: => Any) =                                     // parameters are evaluated lazily when you use it
 

It also uses principles such as add principle by adding new functionality, e.g.

 result + 1
 result.pp + 1
 

Spec also supports table similar to Fit and Fitness for writing concise tests. Overall, I was impressed with wide set of tools for writing tests.

Lift: Quick and Fun

Lift is a Scala based web framework for writing secure, typesafe, concise, and interactive (like desktop) applications. It abstracts much of plumbing of HTTP, which I personally don't like as I have found web frameworks that does that results in leaky abstractions. Lift also uses stateful web applications, which require sticky sessions, which is another area that I have found to be problematic for scalability and upgrade. Here is an example of Lift chat server:

 package code.comet
 import net.liftweb._
 import http._
 import actor._
 import scala.xml.
 object ChatServer extends LiftActor withListenerManager {
         private var msgs = List("Welcome")
         def createUpdate = msgs
         override def lowPriority = {
                 case s: String => msgs ::= s; updateListeners()
         }
 }
 
 class Chat extends CometActor withCometListener {
   private var msgs: List[String] = Nil
   def regiserWith = ChatServer
   override def lowPriority = {
      case l: List[String] = msgs = l; reRender(false)  // don't use reRender
   }
   def line(in: NodeSeq) : NodeSeq = msgs.reverse.flatMap(m => bind("chat", in, "item" -> m))
   def render = bind("chat", "line" -> line _)
 }
 

In Lift, every component has GUID and version that was used to render and then sets up long poll and then receive deltas (every 100ms). You can use sbt to deploy jetty and prepare war file, e.g.

 sbt
 >jetty-run
 >prepareWeb                                                     // uses JRebel to reload classes
 

Rewiring Android with Scala

This was another interesting talk by Nathan Hamblen for using Scala for writing Android applications. The key selling point of Scala has been conciseness of the language, and you can write simple code such as:

 dialog.setOnShowListener { di: DialogInterface => 
   runSomeCode() 
 }
 

instead of

 dialog.setOnShowListener(
   new DialogInterface.OnShowListener() {
     public void onShow(DialogInterface interface) {
       runSomeCode();
     }
   }
 );
 

or

 future { runSomeCode(myObject) }
 

instead of

 new AsyncTask () {
   protected Integer doInBackground(MyObject... objs) {
     runSomeCode(objs[0]);
   }
 }.execute(myObject);
 
 

Nathan showed how you can define Scala traits to add lazy handlers for android code, e.g.

 trait ScalaActivity extends Activity {
 ...
 lazy val handler = new Handler
 def post(block: => Unit) { 
   handler.post(new Runnable{
     def run { block }
   })
 }
 

Or you can extend APIs, e.g.

 implicit def f2cancel(block: DialogInterface => Unit) = 
   new DialogInterface.OnCancelListener {
     def onCancel(dialog: DialogInterface) { 
       block(dialog) 
     }
   }
 ...
 new AlertDialog.Builder(this)
   .setOnCancelListener { 
     di: DialogInterface => finish() 
   }
 

Nathan also showed a plugin (sbt-android-plugin) to create type-safe layout instead of using R.java file generated by Android, which you can get it from git clone git://github.com/meetup/meetabout.git. On the downside, Scala based android applications require Scala jar files and the size of application becomes considerable large. Though, you can use tools to extract the classes that you need, but it would still be larger than Java code.

Scala in Practice

Alex Payne and Coda Hale had a section on Scala in practice, but it was only Q/A session. I was a bit disappointed that they didn't come prepare with actual usage or war stories from their work environment.

High Wizardry in the Land of Scala

The last section of the day was a bit on type and category theory, which was interesting but mostly theortical. Daniel Spiewak explained difference between kind and type system. The only tip from the session I got was that Values are to types as types are to kinds. Finally, Daniel explained that newly released 2.8.0 version of Scala supports continuation but it's all broken and useless.

Summary

Overall, I found sessions on both Android and Scala were well worth the time and it peaked my interest in both. I think the ecosystem of Scala has matured and there is better tools support with the new version (2.8). I am going to try to influence co-workers into using it for new development. I am also going to start Android project pretty soon but I am a bit hesitant on writing in Scala due to increased application size.

I have been using SMTPAppender for a while to notify developers when something breaks on the production site and for most part it works well. However, due to some misconfiguration or service crash it can result in large number of emails. I was struck by similar problem at work when my email box suddently got tons of emails from the production site. So I decided to write a bit intelligent email appender. My goals for the appender were:

• Throttle emails based on some configured time
• Remove duplicate emails
• Support JMX for dynamic configuration
• Provide summary report with count of errors and their timings

I created FilteredSMTPAppender class that extends SMTPAppender. The FilteredSMTPAppender defines a nested class Stats for keeping track of errors. For each unique exception, it creates an instance of Stats, that stores the first and last occurrence of this exception as well as count. The Stats class uses hash of stack trace to identify unique exceptions, however it ignores first line, which often stores some dynamic information. FilteredSMTPAppender registers iteslf as MBean so that it can be configured at runtime. It overrides append method to capture the event and overrides checkEntryConditions to add filtering. It also changes the layout so that the summary count of error messages are added to the footer of email message.

The FilteredSMTPAppender uses a number of helper classes such as ServiceJMXBeanImpl for MBean definition, LRUSortedList to keep fixed cache of exceptions. Here is listing of LRUSortedList and ServiceJMXBeanImpl.

Listing of FilteredSMTPAppender.java

   1 package com.plexobject.log;
 
   2 
   3 import java.beans.PropertyChangeEvent;
   4 import java.beans.PropertyChangeListener;
   5 import java.util.Comparator;
 
   6 import java.util.Date;
   7 
   8 import javax.mail.MessagingException;
   9 
 
  10 import org.apache.commons.lang.builder.EqualsBuilder;
  11 import org.apache.commons.lang.time.FastDateFormat;
  12 
  13 import org.apache.log4j.Layout;
 
  14 import org.apache.log4j.net.SMTPAppender;
  15 import org.apache.log4j.spi.LoggingEvent;
  16 
  17 import com.plexobject.jmx.JMXRegistrar;
 
  18 import com.plexobject.jmx.impl.ServiceJMXBeanImpl;
  19 import com.plexobject.metrics.Metric;
  20 import com.plexobject.metrics.Timer;
 
  21 import com.plexobject.util.Configuration;
  22 import com.plexobject.util.LRUSortedList;
  23 
  24 public class FilteredSMTPAppender extends SMTPAppender {
 
  25 
  26     private static final String SMTP_FILTER_MIN_DUPLICATE_INTERVAL_SECS = "smtp.filter.min.duplicate.interval.secs";
  27     private static final int MAX_STATS = Configuration.getInstance().getInteger("smtp.filter.max", 100);
 
  28     private static int MIN_DUPLICATE_EMAILS_INTERVAL = Configuration.getInstance().getInteger(SMTP_FILTER_MIN_DUPLICATE_INTERVAL_SECS,
  29             60); // 1 minute
  30     private static final Date STARTED = new Date();
 
  31     private static final FastDateFormat DATE_FMT = FastDateFormat.getInstance("MM/dd/yy HH:mm");
  32 
  33     final static class Stats implements Comparable<Stats> {
 
  34 
  35         final int checksum;
  36         final long firstSeen;
 
  37         long lastSeen;
  38         long lastSent;
  39         int numSeen;
 
  40         int numEmails;
  41 
  42         Stats(LoggingEvent event) {
  43             StringBuilder sb = new StringBuilder();
 
  44             String[] trace = event.getThrowableStrRep();
  45             for (int i = 1; i < trace.length && i < 20; i++) { // top 20 lines
 
  46                 // of trace
  47                 sb.append(trace[i].trim());
  48             }
  49             this.checksum = sb.toString().hashCode();
 
  50             firstSeen = lastSeen = System.currentTimeMillis();
  51             numSeen = 1;
  52         }
  53 
  54         boolean check() {
 
  55             long current = System.currentTimeMillis();
  56             long elapsed = current - lastSent;
  57 
  58             numSeen++;
 
  59             lastSeen = current;
  60 
  61             if (elapsed > MIN_DUPLICATE_EMAILS_INTERVAL * 1000) {
  62                 lastSent = current;
 
  63                 numEmails++;
  64                 return true;
  65             } else {
 
  66                 return false;
  67             }
  68         }
  69 
 
  70         @Override
  71         public boolean equals(Object object) {
  72             if (!(object instanceof Stats)) {
 
  73                 return false;
  74             }
  75             Stats rhs = (Stats) object;
  76             return new EqualsBuilder().append(this.checksum, rhs.checksum).isEquals();
 
  77 
  78         }
  79 
  80         @Override
  81         public int hashCode() {
 
  82             return checksum;
  83         }
  84 
  85         @Override
 
  86         public String toString() {
  87             return " (" + checksum + ") occurred " + numSeen + " times, " + numEmails + " # of emails, first @" + DATE_FMT.format(new Date(firstSeen)) + ", last @" + DATE_FMT.format(new Date(lastSeen)) + " since server started @" + DATE_FMT.format(STARTED);
 
  88         }
  89 
  90         @Override
  91         public int compareTo(Stats other) {
 
  92             return checksum - other.checksum;
  93         }
  94     }
  95 
 
  96     final static class StatsCmp implements Comparator<Stats> {
  97 
 
  98         @Override
  99         public int compare(Stats first, Stats second) {
 100             return first.checksum - second.checksum;
 
 101         }
 102     }
 103     private static final LRUSortedList<Stats> STATS_LIST = new LRUSortedList<Stats>(
 
 104             MAX_STATS, new StatsCmp());
 105     private LoggingEvent event;
 106     private ServiceJMXBeanImpl mbean;
 107     private Layout layout;
 
 108 
 109     public FilteredSMTPAppender() {
 110         mbean = JMXRegistrar.getInstance().register(getClass());
 111         mbean.addPropertyChangeListener(new PropertyChangeListener() {
 112 
 
 113             @Override
 114             public void propertyChange(PropertyChangeEvent event) {
 115                 try {
 116                     if (event != null && SMTP_FILTER_MIN_DUPLICATE_INTERVAL_SECS.equalsIgnoreCase(event.getPropertyName())) {
 
 117                         MIN_DUPLICATE_EMAILS_INTERVAL = Integer.parseInt((String) event.getNewValue());
 118                     }
 119                 } catch (Exception e) {
 120                     e.printStackTrace();
 121                 }
 
 122             }
 123         });
 124 
 125     }
 126 
 127     public void append(LoggingEvent event) {
 
 128         this.event = event;
 129         if (layout == null) {
 130             layout = getLayout();
 131         }
 
 132         super.append(event);
 133     }
 134 
 135     protected boolean checkEntryConditions() {
 136         final Timer timer = Metric.newTimer(getClass().getSimpleName() + ".checkEntryConditions");
 
 137         try {
 138             boolean check = true;
 139             if (event != null) {
 
 140                 Stats newStats = new Stats(event);
 141                 Stats stats = STATS_LIST.get(newStats);
 142                 if (stats == null) {
 143                     stats = newStats;
 
 144                     STATS_LIST.add(stats);
 145                 } else {
 146                     check = stats.check();
 147                 }
 148                 if (check) {
 
 149                     setMessageFooter(stats);
 150                 }
 151             }
 152             return check && super.checkEntryConditions();
 
 153         } finally {
 154             timer.stop();
 155         }
 156     }
 157 
 
 158     private void setMessageFooter(Stats stats) {
 159         String message = event.getMessage().toString();
 160 
 161         final String footer = "\n\n-------------------------\n" + message + " - " + stats;
 
 162 
 163         if (layout != null) {
 164             setLayout(new Layout() {
 165 
 
 166                 @Override
 167                 public void activateOptions() {
 168                     layout.activateOptions();
 169 
 170                 }
 
 171 
 172                 @Override
 173                 public String format(LoggingEvent evt) {
 174                     return layout.format(evt);
 175                 }
 
 176 
 177                 @Override
 178                 public String getFooter() {
 179                     return footer;
 180                 }
 
 181 
 182                 @Override
 183                 public boolean ignoresThrowable() {
 184                     return layout.ignoresThrowable();
 
 185                 }
 186             });
 187         }
 188     }
 189 }
 190 
 
 191 
 

Listing of ServiceJMXBeanImpl.java

   1 package com.plexobject.util;
 
   2 
   3 import java.util.ArrayList;
   4 import java.util.Collection;
   5 import java.util.Collections;
 
   6 import java.util.Comparator;
   7 import java.util.Iterator;
   8 import java.util.List;
 
   9 import java.util.ListIterator;
  10 
  11 import org.apache.log4j.Logger;
  12 
 
  13 
  14 public class LRUSortedList<T> implements List<T> {
 
  15     private static final Logger LOGGER = Logger.getLogger(LRUSortedList.class);
  16     private final int max;
 
  17     private final Comparator<T> comparator;
  18 
  19     private final List<Pair<Long, T>> list = new ArrayList<Pair<Long, T>>();
 
  20     private final List<Pair<Long, Integer>> timestamps = new ArrayList<Pair<Long, Integer>>();
 
  21 
  22     // comparator to sort by timestamp
  23     private static final Comparator<Pair<Long, Integer>> CMP = new Comparator<Pair<Long, Integer>>() {
 
  24         @Override
  25         public int compare(Pair<Long, Integer> first, Pair<Long, Integer> second) {
 
  26             if (first.getFirst() < second.getFirst()) {
  27                 return -1;
  28             } else if (first.getFirst() > second.getFirst()) {
 
  29                 return 1;
  30             } else {
  31                 return 0;
 
  32             }
  33         }
  34     };
  35 
  36     public LRUSortedList(int max, Comparator<T> comparator) {
 
  37         this.max = max;
  38         this.comparator = comparator;
  39     }
  40 
 
  41     @Override
  42     public boolean add(T e) {
  43         if (list.size() > max) {
 
  44             removeOldest();
  45         }
  46         // add object
  47         long timestamp = System.nanoTime();
 
  48         int insertionIdx = Collections.binarySearch(this, e, comparator);
  49         if (insertionIdx < 0) {// not found
 
  50             insertionIdx = (-insertionIdx) - 1;
  51             list.add(insertionIdx, new Pair<Long, T>(timestamp, e));
  52         } else {
 
  53             // found
  54             list.set(insertionIdx, new Pair<Long, T>(timestamp, e));
  55         }
 
  56 
  57         // as timestamps are sorted, we just remove the oldest (first)
  58         if (timestamps.size() > max) {
 
  59             timestamps.remove(0);
  60         }
  61         // update timestamp
  62         Pair<Long, Integer> t = new Pair<Long, Integer>(timestamp, insertionIdx);
 
  63         timestamps.add(t);
  64         return true;
  65     }
  66 
 
  67     @Override
  68     public void add(int index, T element) {
  69         throw new UnsupportedOperationException(
 
  70                 "can't add element at arbitrary index, must use add to keep sorted order");
  71     }
  72 
  73     @Override
 
  74     public boolean addAll(Collection<? extends T> c) {
  75         for (T e : c) {
 
  76             add(e);
  77         }
  78         return c.size() > 0;
  79     }
 
  80 
  81     @Override
  82     public boolean addAll(int index, Collection<? extends T> c) {
 
  83         throw new UnsupportedOperationException(
  84                 "can't add element at arbitrary index, must use addAll to keep sorted order");
  85     }
 
  86 
  87     @Override
  88     public void clear() {
  89         list.clear();
 
  90     }
  91 
  92     @SuppressWarnings("unchecked")
  93     @Override
 
  94     public boolean contains(Object e) {
  95         if (e == null) {
  96             return false;
 
  97         }
  98         try {
  99             return Collections.binarySearch(this, (T) e, comparator) >= 0;
 
 100         } catch (ClassCastException ex) {
 101             LOGGER.error("Unexpected type for contains "
 102                     + e.getClass().getName() + ": " + e);
 
 103             return false;
 104         }
 105     }
 106 
 107     @Override
 
 108     public boolean containsAll(Collection<?> c) {
 109         for (Object e : c) {
 110             if (!contains(e)) {
 
 111                 return false;
 112             }
 113         }
 114         return true;
 
 115     }
 116 
 117     @Override
 118     public T get(int index) {
 119         Pair<Long, T> e = list.get(index);
 
 120         return e != null ? e.getSecond() : null;
 121     }
 122 
 123     public T get(Object e) {
 
 124         int ndx = indexOf(e);
 125         if (ndx >= 0) {
 126             return get(ndx);
 127         }
 
 128         return null;
 129     }
 130 
 131     @SuppressWarnings("unchecked")
 132     @Override
 
 133     public int indexOf(Object e) {
 134         try {
 135             return Collections.binarySearch(this, (T) e, comparator);
 
 136         } catch (ClassCastException ex) {
 137             LOGGER.error("Unexpected type for get " + e.getClass().getName()
 138                     + ": " + e);
 
 139             return -1;
 140         }
 141     }
 142 
 143     @Override
 144     public boolean isEmpty() {
 
 145         return list.isEmpty();
 146     }
 147 
 148     @Override
 149     public Iterator<T> iterator() {
 
 150         final Iterator<Pair<Long, T>> it = list.iterator();
 151         return new Iterator<T>() {
 
 152 
 153             @Override
 154             public boolean hasNext() {
 155                 return it.hasNext();
 
 156             }
 157 
 158             @Override
 159             public T next() {
 160                 Pair<Long, T> e = it.next();
 
 161                 return e.getSecond();
 162             }
 163 
 164             @Override
 165             public void remove() {
 
 166                 it.remove();
 167             }
 168         };
 169     }
 170 
 171     @Override
 
 172     public int lastIndexOf(Object o) {
 173         for (int i = list.size() - 1; i >= 0; i--) {
 174             T e = get(i);
 
 175             if (e.equals(o)) {
 176                 return i;
 177             }
 178         }
 179         return -1;
 
 180     }
 181 
 182     @Override
 183     public ListIterator<T> listIterator() {
 184         final ListIterator<Pair<Long, T>> it = list.listIterator();
 
 185         return buildListIterator(it);
 186     }
 187 
 188     @Override
 189     public ListIterator<T> listIterator(int index) {
 
 190         final ListIterator<Pair<Long, T>> it = list.listIterator(index);
 191         return buildListIterator(it);
 192     }
 
 193 
 194     @SuppressWarnings("unchecked")
 195     @Override
 196     public boolean remove(Object e) {
 
 197         try {
 198             int ndx = Collections.binarySearch(this, (T) e, comparator);
 199             if (ndx >= 0) {
 
 200                 remove(ndx);
 201                 return true;
 202             } else {
 203                 return false;
 
 204             }
 205 
 206         } catch (ClassCastException ex) {
 207             LOGGER.error("Unexpected type for remove " + e.getClass().getName()
 
 208                     + ": " + e);
 209             return false;
 210         }
 211     }
 
 212 
 213     @Override
 214     public T remove(int index) {
 215         Pair<Long, T> e = list.remove(index);
 
 216         Pair<Long, Integer> t = new Pair<Long, Integer>(e.getFirst(), 0);
 217 
 218         int insertionIdx = Collections.binarySearch(timestamps, t, CMP);
 
 219         if (insertionIdx >= 0) {
 220             timestamps.remove(insertionIdx);
 221         }
 222         return e != null ? e.getSecond() : null;
 
 223     }
 224 
 225     @Override
 226     public boolean removeAll(Collection<?> c) {
 
 227         boolean all = true;
 228         for (Object e : c) {
 229             all = all && remove(e);
 
 230         }
 231         return all;
 232     }
 233 
 234     @Override
 235     public boolean retainAll(Collection<?> c) {
 
 236         boolean changed = false;
 237         Iterator<?> it = c.iterator();
 238         while (it.hasNext()) {
 
 239             Object e = it.next();
 240             if (!contains(e)) {
 241                 it.remove();
 242                 changed = true;
 243             }
 
 244         }
 245         return changed;
 246     }
 247 
 248     @Override
 
 249     public T set(int index, T element) {
 250         throw new UnsupportedOperationException();
 251     }
 
 252 
 253     @Override
 254     public int size() {
 255         return list.size();
 
 256     }
 257 
 258     @Override
 259     public List<T> subList(int fromIndex, int toIndex) {
 
 260         List<T> tlist = new ArrayList<T>();
 261         List<Pair<Long, T>> plist = list.subList(fromIndex, toIndex);
 
 262         for (Pair<Long, T> e : plist) {
 263             tlist.add(e.getSecond());
 264         }
 265         return tlist;
 
 266     }
 267 
 268     @Override
 269     public Object[] toArray() {
 270         return subList(0, list.size()).toArray();
 
 271     }
 272 
 273     @SuppressWarnings("hiding")
 274     @Override
 275     public <T> T[] toArray(T[] a) {
 
 276         return subList(0, list.size()).toArray(a);
 277     }
 278 
 279     @Override
 280     public String toString() {
 
 281         StringBuilder sb = new StringBuilder();
 282         Iterator<T> it = iterator();
 283         while (it.hasNext()) {
 
 284             sb.append(it.next() + ", ");
 285         }
 286         return sb.toString();
 287     }
 288 
 
 289     private void removeOldest() {
 290         timestamps.remove(timestamps.size() - 1);
 291     }
 292 
 293     private ListIterator<T> buildListIterator(
 
 294             final ListIterator<Pair<Long, T>> it) {
 295         return new ListIterator<T>() {
 
 296 
 297             @Override
 298             public void add(T e) {
 299                 it.add(new Pair<Long, T>(System.nanoTime(), e));
 
 300             }
 301 
 302             @Override
 303             public boolean hasNext() {
 304                 return it.hasNext();
 
 305 
 306             }
 307 
 308             @Override
 309             public boolean hasPrevious() {
 
 310                 return it.hasPrevious();
 311 
 312             }
 313 
 314             @Override
 315             public T next() {
 
 316                 Pair<Long, T> e = it.next();
 317                 return e.getSecond();
 318             }
 319 
 320             @Override
 
 321             public int nextIndex() {
 322                 return it.nextIndex();
 323 
 324             }
 
 325 
 326             @Override
 327             public T previous() {
 328                 Pair<Long, T> e = it.previous();
 
 329                 return e.getSecond();
 330             }
 331 
 332             @Override
 333             public int previousIndex() {
 
 334                 return it.previousIndex();
 335 
 336             }
 337 
 338             @Override
 339             public void remove() {
 
 340                 it.remove();
 341 
 342             }
 343 
 344             @Override
 345             public void set(T e) {
 
 346                 it.set(new Pair<Long, T>(System.nanoTime(), e));
 347 
 348             }
 349         };
 350     }
 
 351 
 352 }
 353 
 354 
 

Listing of LRUSortedList.java

   1 package com.plexobject.jmx.impl;
 
   2 
   3 import java.beans.PropertyChangeListener;
   4 import java.beans.PropertyChangeSupport;
   5 import java.util.Map;
 
   6 import java.util.concurrent.ConcurrentHashMap;
   7 import java.util.concurrent.atomic.AtomicLong;
   8 
   9 import javax.management.AttributeChangeNotification;
 
  10 import javax.management.MBeanNotificationInfo;
  11 import javax.management.Notification;
  12 import javax.management.NotificationBroadcasterSupport;
 
  13 import javax.management.NotificationListener;
  14 
  15 import org.apache.commons.lang.builder.EqualsBuilder;
  16 import org.apache.commons.lang.builder.HashCodeBuilder;
 
  17 import org.apache.commons.lang.builder.ToStringBuilder;
  18 import org.apache.log4j.Logger;
  19 
  20 import com.plexobject.jmx.ServiceJMXBean;
 
  21 import com.plexobject.metrics.Metric;
  22 import com.plexobject.util.TimeUtils;
  23 
  24 public class ServiceJMXBeanImpl extends NotificationBroadcasterSupport
 
  25         implements ServiceJMXBean, NotificationListener {
  26     private static final Logger LOGGER = Logger
  27             .getLogger(ServiceJMXBeanImpl.class);
 
  28     private Map<String, String> properties = new ConcurrentHashMap<String, String>();
  29     private final PropertyChangeSupport pcs = new PropertyChangeSupport(this);
 
  30 
  31     private final String serviceName;
  32     private AtomicLong totalErrors;
 
  33     private AtomicLong totalRequests;
  34 
  35     private AtomicLong sequenceNumber;
  36     private String state;
 
  37 
  38     public ServiceJMXBeanImpl(final String serviceName) {
  39         this.serviceName = serviceName;
 
  40         this.totalErrors = new AtomicLong();
  41         this.totalRequests = new AtomicLong();
  42         this.sequenceNumber = new AtomicLong();
 
  43     }
  44 
  45     @Override
  46     public double getAverageElapsedTimeInNanoSecs() {
 
  47         return Metric.getMetric(getServiceName())
  48                 .getAverageDurationInNanoSecs();
  49     }
  50 
 
  51     public String getProperty(final String name) {
  52         return properties.get(name);
  53     }
 
  54 
  55     public void setProperty(final String name, final String value) {
 
  56         final String oldValue = properties.put(name, value);
  57         final Notification notification = new AttributeChangeNotification(this,
 
  58                 sequenceNumber.incrementAndGet(), TimeUtils
  59                         .getCurrentTimeMillis(), name + " changed", name,
  60                 "String", oldValue, value);
  61         sendNotification(notification);
 
  62         handleNotification(notification, null);
  63     }
  64 
  65     @Override
 
  66     public String getServiceName() {
  67         return serviceName;
  68     }
  69 
 
  70     @Override
  71     public long getTotalDurationInNanoSecs() {
  72         return Metric.getMetric(getServiceName()).getTotalDurationInNanoSecs();
 
  73     }
  74 
  75     @Override
  76     public long getTotalErrors() {
 
  77         return totalErrors.get();
  78     }
  79 
  80     public void incrementError() {
 
  81         final long oldErrors = totalErrors.getAndIncrement();
  82         final Notification notification = new AttributeChangeNotification(this,
 
  83                 sequenceNumber.incrementAndGet(), TimeUtils
  84                         .getCurrentTimeMillis(), "Errors changed", "Errors",
  85                 "long", oldErrors, oldErrors + 1);
 
  86         sendNotification(notification);
  87     }
  88 
  89     @Override
  90     public long getTotalRequests() {
 
  91         return totalRequests.get();
  92     }
  93 
  94     public void incrementRequests() {
 
  95         final long oldRequests = totalRequests.getAndIncrement();
  96         final Notification notification = new AttributeChangeNotification(this,
 
  97                 sequenceNumber.incrementAndGet(), TimeUtils
  98                         .getCurrentTimeMillis(), "Requests changed",
  99                 "Requests", "long", oldRequests, oldRequests + 1);
 
 100         sendNotification(notification);
 101     }
 102 
 103     @Override
 104     public MBeanNotificationInfo[] getNotificationInfo() {
 105         String[] types = new String[] { AttributeChangeNotification.ATTRIBUTE_CHANGE };
 
 106         String name = AttributeChangeNotification.class.getName();
 107         String description = "An attribute of this MBean has changed";
 108         MBeanNotificationInfo info = new MBeanNotificationInfo(types, name,
 
 109                 description);
 110 
 111         return new MBeanNotificationInfo[] { info };
 112     }
 113 
 
 114     @Override
 115     public String getState() {
 116         return state;
 117     }
 118 
 
 119     /**
 120      * @param state
 121      *            the state to set
 
 122      */
 123     public void setState(String state) {
 124         this.state = state;
 125     }
 
 126 
 127     /**
 128      * @see java.lang.Object#equals(Object)
 
 129      */
 130     @Override
 131     public boolean equals(Object object) {
 132         if (!(object instanceof ServiceJMXBeanImpl)) {
 
 133             return false;
 134         }
 135         ServiceJMXBeanImpl rhs = (ServiceJMXBeanImpl) object;
 136         return new EqualsBuilder().append(this.serviceName, rhs.serviceName)
 
 137                 .isEquals();
 138     }
 139 
 140     /**
 141      * @see java.lang.Object#hashCode()
 
 142      */
 143     @Override
 144     public int hashCode() {
 145         return new HashCodeBuilder(786529047, 1924536713).append(
 
 146                 this.serviceName).toHashCode();
 147     }
 148 
 149     /**
 150      * @see java.lang.Object#toString()
 
 151      */
 152     @Override
 153     public String toString() {
 154         return new ToStringBuilder(this)
 
 155                 .append("serviceName", this.serviceName).append("totalErrors",
 156                         this.totalErrors).append("totalRequests",
 157                         this.totalRequests).append("totalRequests",
 
 158                         this.totalRequests).append("state", this.state).append(
 159                         "properties", this.properties).toString();
 160     }
 
 161 
 162     public void addPropertyChangeListener(PropertyChangeListener pcl) {
 163         pcs.addPropertyChangeListener(pcl);
 164     }
 165 
 
 166     public void removePropertyChangeListener(PropertyChangeListener pcl) {
 167         pcs.removePropertyChangeListener(pcl);
 168 
 169     }
 170 
 
 171     @Override
 172     public void handleNotification(Notification notification, Object handback) {
 173         LOGGER.info("Received notification: ClassName: "
 174                 + notification.getClass().getName() + ", Source: "
 
 175                 + notification.getSource() + ", Type: "
 176                 + notification.getType() + ", tMessage: "
 177                 + notification.getMessage());
 178         if (notification instanceof AttributeChangeNotification) {
 
 179             AttributeChangeNotification acn = (AttributeChangeNotification) notification;
 180             pcs.firePropertyChange(acn.getAttributeName(), acn.getOldValue(),
 181                     acn.getNewValue());
 182 
 183         }
 184     }
 
 185 }
 186 
 187 
 

Testing

Finally, here is how you can test this filter:

  1 package com.plexobject;
 
  2 
  3 import java.net.InetAddress;
  4 import java.util.Date;
  5 
 
  6 import org.apache.log4j.Logger;
  7 import org.apache.log4j.PatternLayout;
  8 import org.apache.log4j.net.SMTPAppender;
 
  9 
 10 import com.plexobject.log.FilteredSMTPAppender;
 11 
 12 public class Main {
 
 13     private static final Logger LOGGER = Logger.getLogger(Main.class);
 14     public static void main(String[] args) {
 
 15         SMTPAppender appender = new FilteredSMTPAppender();
 16         try {
 17             appender.setTo("bhatti@xxx.com");
 18             appender.setFrom("bhatti@xxx.com");
 
 19             appender.setSMTPHost("smtp.xxx.net");
 20             appender.setLocationInfo(true);
 21             appender.setSubject("Error from " + InetAddress.getLocalHost());
 22 
 
 23             appender.setLayout(new PatternLayout());
 24             appender.activateOptions();
 25             LOGGER.addAppender(appender);
 26         } catch (Exception e) {
 
 27             LOGGER.error("Failed to register smtp appender", e);
 28         }
 29         while (true) {
 30             try {
 
 31                 throw new Exception("throwing exception at " + new Date());
 32             } catch (Exception e) {
 
 33                 LOGGER.error("Logging error at " + new Date(), e);
 34             }
 35             try {
 
 36                 Thread.sleep(1000);
 37             } catch (InterruptedException e) {
 38                 Thread.interrupted();
 39             }
 40         }
 
 41     }
 42 }
 43 
 44 
 

Above code simulates error generation every second, but it sends email based on the throttling level defined in the configuration. Obviously you can use log4j properties file to define all this configuration, e.g.

<!– Send email when error happens –>
<appender name=”APP-EMAIL” class=”com.plexobject.log.FilteredSMTPAppender”>
<param name=”BufferSize” value=”256″ />
<param name=”SMTPHost” value=”smtp.xxx.net” />
<param name=”From” value=”bhatti@xxx.com” />
<param name=”To” value=”bhatti@xxx.com” />
<param name=”Subject” value=”Production Error” />
<layout class=”org.apache.log4j.PatternLayout”>
<param name=”ConversionPattern”
value=”[%d{ISO8601}]%n%n%-5p%n%n%c%n%n%m%n%n” />
</layout>

<filter class=”org.apache.log4j.varia.StringMatchFilter”>
<param name=”StringToMatch” value=”My Error”/>
<param name=”AcceptOnMatch” value=”false” />
</filter>
</appender>

Summary

I am skipping other classes, but you can download entire code from FilteredSMTPAppender.zip. This solution seems to be working from me but feel free to share your experience with similar problems.