WeigleWilczek Company Blog

SLF4S – Logging the Scala way

Heiko Seeberger — Thu, 02 Sep 2010 17:54:00 +0000

Do we need another logging framework in the Java/Scala world? Certainly not! As Scala is fully "downward" compatible to Java, we can use whatever Java logging solution we want. And there are many, aren't there?.

So why SLF4S? Well, SLF4S isn't another logging framework, but a very thin Scala wrapper around SLF4J which has emerged as the leading Java logging solution. Why do we need a Scala wrapper for SLF4S? Well, there are some nice Scala features that can make logging even easier and/or more performant.

First, SLF4J Loggers use by-name parameters which are only evaluated if needed/accessed. When logging "traditionally", we often create messages by concatenating Strings or using the String.format method, even if we don't need these messages in the end because the logging level is not enabled. Of course we could "manually" check whether the logging level is enabled, e.g. by calling logger.isDebugEnabled, but we often don't, because it's cumbersome. With by-name parameters we can simply call our log methods and let SLF4S check whether the log level is enabled. Just take a look at one example:

def debug(msg: => String) {
 if (slf4jLogger.isDebugEnabled) slf4jLogger debug msg
}

Second, SLF4S offers a Logging trait which can be mixed into any class to make a Logger instance available. That particular Logger will be initialized with the name of the class it is mixed into which is a common use case.

class MyClazz extends SomeClazz with Logging
  ...
  logger debug "SLF4S just rocks!"
  ...

Of course you can create Loggers with arbitrary names by calling Logger("SomeSpecialName").

Last but not least, SLF4S offers implicit conversions from "usual" SLF4J Loggers into "pimped" SLF4S Loggers.

Ah, and of course, SLF4S is OSGi compliant. But that's not a big surprise, taking into account that the authors are OSGi fanboys and SLF4J is OSGi compliant, too.

How to setup a Scala project with SBT and IDEA

Heiko Seeberger — Fri, 06 Aug 2010 13:28:00 +0000

Today I helped my mate Bernd Kolb setting up a simple Scala project. He had been struggling far too long with various options like Maven, SBT, Eclipse and Intellij IDEA. If I remember correctly it only took a 30 minutes conf call to setup a simple Scala and Lift project with SBT and IDEA. But there are quite a few things to know in order to be successful which I am going to describe here in a step-by-step tutorial. I hope you find it useful. Please let me know any issues.

Why SBT and IDEA?

Why not Maven and Eclipse? Or Ant and Netbeans? Or ...? First, we have to make a choice. Second, SBT and IDEA are currently the best build tool and the best IDE for Scala. SBT is written specifically for Scala and offers very fast compilation, interactive mode for continuous compilation, testing, etc., integration for Scala test tools like specs and ScalaTest, cross compiling against different Scala versions and many more. While the Scala IDE for Eclipse recently has made nice progress and the Netbeans plugin looks good, IDEA still offers the best Scala plugin with many features known from a Java IDE, e.g. refactroings, code completion, code navigation, etc.

Preparations

Java 5 or 6 is assumed. Get the SBT launcher and follow the instructions to set it up. Install IDEA 9.0.3 and use its plugin manager to install the Scala plugin. Here we go!

1. Create a SBT project

Create a folder for your project, cd there and run SBT. You will be asked the following questions. Answer like I did or chose different values (except for the Scala version).

Project does not exist, create new project? (y/N/s) y

Name: simple

Organization: localhost

Version [1.0]: 

Scala version [2.7.7]: 2.8.0

sbt version [0.7.4]:

Now SBT will download Scala 2.7.7 as well as some other libraries for internal use. And it will download Scala 2.8.0 which is used to build your project.

As soon as the downloads are finished, you are in SBT's interactive mode. At the prompt enter compile, then ~test (press enter to leave the triggered mode) and then help to make yourself familiar with the features.

Looking at your project in the file system, you will notice a layout similar to Maven: Scala sources go into src/main/scala, Scala tests go into src/test/scala and artifacts go into target. If your project looks different from the one at the right, you probably did not run compile or test. But as it is important to run your project against the same version as it was compiled against, there is a Scala_2.8.0 folder between the target and the classes, test-classes etc.

Update

Thanks to Comments from Bart and Mikko I looked into the sbt-idea-plugin which makes it possible to create the project files for IDEA from SBT. While it is still under active development and there are some minor issues, the current snapshot release 0.1 already produces usable IDEA project files. So you could just go for that plugin and skip the next two steps.

2. Create an IDEA project

Now you have to create an IDEA project on top of your SBT project.

Choose File > New Project ..., select Create project from scratch and continue.

Then pick your project folder for Project files location and continue.

Then enter src/main/scala as path for the source directory and continue.

Now it is getting a little tricky!

Select Scala from the list of technologies.

Ignore the erroneous combo for the Version.

Choose Pick files from disk and select scala-compiler.jar and scala-library.jar form project/boot/scala-2.8.0/lib.

Then change the Name to scala-2.8.0 and click Finish.

3. Adjust IDEA project settings

Now you have make some adjustments to align SBT's and IDEA's project layout.

Choose Modules on the left and navigate to the Sources tab. Add src/main/resources to the Sources (blue) and src/test/scala and src/test/resources to the Test Sources (green). Exclude (red) .idea, lib, project/boot and target.

Next go to the Paths tab and select target/scala_2.8.0/classes for the Output path and target/scala_2.8.0/test-classes for the Test output path.

Then choose the Scala facet from the mid column (below the one and only module simple) and unchek Use Scala compilers ....

That's it! Now you are ready to go.

4. Give it a try

In IDEA go to the src/main/scala folder and choose New > Scala Class from the context menu. Call it Hello and make it an Object.

In the editor delete the package statement and enter the following code:

object Hello {

  def main(args: Array[String]) {

    println("Hello!")

  }

}

From the context menu choose Run Hello.main(). IDEA will build your project and then run this object.

After that go to SBT and enter ~run. Watch the output and look for the Hello! message. Then change the message in the code, e.g. to Hello, world!. As you have told SBT to use triggered run by prefixing whith the tilda, your project will be incrementally built and the Hello object run again: Watch the output.

Have fun with Scala, SBT and IDEA!

Fully automated Web Application Testing with Selenium and Hudson

Jan Blankenhorn — Wed, 23 Dec 2009 14:38:00 +0000

Lately i have been setting up a fully autometd Web Application Test environment. I just wanted to share my experiences!

My application has a number of selenium tests that i wanted to run on our continious integration server (hudson). My current scenario includes the following steps:

Start the Selenium-RC server from Hudson
Compile the application and the test cases
Reinitialization of the database via DBUnit
Starting the Tomcat - application server
Running the Selenium test cases
Publish the test results in Hudson

Start the Selenium-RC server on Hudson
The Selenium RC server is started from Hudson at the beginning of each build as a shell call.

As you can see in the picture this step is done before i trigger an ant script which includes all the following steps. Therefore it is imperative that a user is logged on to the DISPLAY =: 0.

The full command is here (As you can see, i also specified the path to a logfile):

DISPLAY=:0 java -jar ${WORKSPACE}/ecm.server/lib/test/selenium/selenium-server.jar -log ${WORKSPACE}/ecm.server/selenium.log &

Compile the application of the test cases by Ant +

The first step that is triggered from the ant script is a full build of the webapplication and the selenium test cases.

Reinitialization of the database from Ant via DBUnit

The next step is a full reset of the database used by the application with a initial set of data. Using DBUnit this can be done very easy. I just made an export from an initial dataset which is written to the database every build. Here you can see the ant target which does the job.

Starting the Tomcat - application server from Hudson

I also setup a dedicated tomcat on the build machine used for the selenium testcases. It is started from the Ant script in the next step. You can see the ant script here, note that ant is waiting until tomcat is started up by checking if the webport of tomcat is online.

Running the Selenium test cases from Hudson, by Ant

the Selenium tests are also run from Antwith the following ant script:

As you can see at first i delete the old test results. After that the tests are run via the testng ant task using ReportNG to generate some nice looking test results.

Publish the test results in Hudson

After the tests are run i use two hudson Post-build Actions to publish the test results.

The first is Archive the artifacts:

This Actions archives all resources of the specified folder from the last build. Thiese are the generated TestResults which provide some nice looking results.

In order to get statistics of all test cases ever run i also use the Action Publish JUnit test result report, which uses the Junit xml Resultfiles and generates statisics.

The result can be seen in the hudson project page. There you see an overview of the test statisics.

By clicking on the archived "index.html" you can display the reportng testresult:

Cheers

ScalaModules slides from W-JAX 09 online

Heiko Seeberger — Thu, 12 Nov 2009 16:07:00 +0000

There were a lot of interesting talks at the OSGi Day at W-JAX. If you are interested in the slides of my ScalaModules talk you can take it from here: http://www.slideshare.net/heiko.seeberger/wjax-09-scalamodules

Lift slides from W-JAX 09 online

Heiko Seeberger — Wed, 11 Nov 2009 18:52:00 +0000

The Scala Day at W-JAX was a great success: Many cool talks and lots of interested folks. If you are interested in the slides of my Lift talk you can take it from here: http://www.slideshare.net/heiko.seeberger/wjax-09-lift

Scala 2.8: Be more concise with named and default arguments

Heiko Seeberger — Fri, 16 Oct 2009 07:08:00 +0000

Scala 2.8 will bring quite a lot of interesting new features, e.g. redesigned collection libraries, named and default arguments, support for continuations, a pimped REPL, etc. In the following I will show how named and default arguments enable us to write our Scala code even more concisely than before.

Let's flesh out an example in the 2.7 style: An order with an ID, order items and a shipping mode.


case class Order27(id: Long,
                items: List[Item],
                mode: ShippingMode)

case class Item()

sealed trait ShippingMode
case object StandardShipping extends ShippingMode
case object ExpressShipping extends ShippingMode
case object OvernightShipping extends ShippingMode

The order's ID shall be "mandatory" while we want to allow for defaults for the item list and the shipping mode. Hence we have to provide some auxiliary constructors.


case class Order27(id: Long,
                items: List[Item],
                mode: ShippingMode) {

 def this(id: Long, items: List[Item]) =
   this(id, items, StandardShipping)

 def this(id: Long, mode: ShippingMode) =
   this(id, Nil, StandardShipping)

 def this(id: Long) =
   this(id, Nil, StandardShipping)
}

As you can see, now it is possible to create an order by only giving the ID, e.g.


val order = Order27(1)

will create an order with the items set to the empty list (OK, this does not make too much sense in practice) and the shipping mode set to standard shipping.

On the one hand that's nice. But on the other hand the code is blown up significantly and it will take the reader some time to reason about the different possibilities to create an order, what is mandatory and what is optional with defaults.

Scala 2.8 let's us define default values with the class (or method) parameters by simply putting the default values behind the type.


case class Order28(id: Long,
                items: List[Item] = Nil,
                mode: ShippingMode = StandardShipping)

Now we can leave out the arguments for which defaults are defined, e.g.


val order = Order28(1)

will again create an order with no items and standard shipping. But this time there is no auxiliary constructor necessary to achieve that. Wow!

But how can we give the shipping mode and leave out the items? Looking at the order of the parameters in the primary constructor it is obvious that we have to give the item list before the shipping mode.


val order = Order28(1, HERE GOES THE ITEM LIST, OvernightShipping)

This is where named arguments enter the game. We simply prepend an argument value with its name, e.g.


val order = Order28(1, mode = OvernightShipping)

This way Scala knows how to get things right. Wow!!

Invitation to improve ScalaModules’s DSL

Heiko Seeberger — Sat, 12 Sep 2009 14:03:00 +0000

Over the last months the ScalaModules team has worked on the upcoming 2.0 release. There will be a lot of improvements, e.g. auto-registration of service interfaces, operator notation, filters as objects and the user guide transferred to the Wiki. We are not ready for a final release yet, but most things should already be fairly stable.

There is still one thing we are racking our brains over a lot and maybe one of you could come up with a better solution that we have got right now. The new API for registering services offers auto-registration of service interfaces, such that there is no need to explicitly define the service interface(s). The following snippet will register the service greeting under the service interface Greeting, because greeting implements Greeting.

trait Greeting ...

val greeting = ...

ctx register greeting

Of course there are times when you want to explicitly register a service under a certain service interface. Now it would be very nice to write something like

ctx register greeting as classOf[AnotherInterface]

But this will not work in the current implementation, because register will be executed before as, which will register greeting under Greeting, just like above. Hence you have to use parenthesis like

ctx register (greeting as classOf[AnotherInterface])

Of course we have come up with a nice operator notation which takes the neccessary precedence into account. You could register greeting under the service interface AnotherInterface like this

ctx < greeting / classOf[AnotherInterface]

There is no need to use parenthesis here, because / will be executed first, because its precedence is higher than <.

But we would still like to get rid of the parenthesis in the "wordy" style. Roman already came up with an idea which you can take from the ScalaModules Google group. But when it comes to using as and withProps at the same time this is not adequate. So the question is, whether you have an idea how we could write something like

ctx register as classOf[AnotherInterface] withProps ("x" -> "y")

I am looking forward for your suggestions!

OSGi-fied Scala libraries updated to 2.7.6

Heiko Seeberger — Sat, 12 Sep 2009 11:38:00 +0000

Now that we have got Scala 2.7.6 I also updated the OSGi version of the Scala libraries. Please take it from the scala-tools.org Maven repository.

Currently there is an ongoing discussion about modularizing the official Scala code base, just take a look at the scala-internals mailing list. Hopefully we will see some success soon which might make the extra OSGi version obsolete though. But right now these extra OSGi-fied libraries are the way to go if you want to run OSGi on Scala or Scala on OSGi.

Eclipse Insurance Day 30.9.09 in Köln

Jörn Weigle — Thu, 10 Sep 2009 14:06:42 +0000

Nach den Erfolgen der Eclipse Banking Days veranstaltet WW nun eine Fachkonferenz zu Open Source-basierten Lösungen für Versicherungen. Der technologische Schwerpunkt liegt auf Eclipse, allerdings richtet sich die Veranstaltung primär an IT-Entscheider aus Versicherungen und IT-Dienstleistern für Versicherungen. Redner sind u.a. Mike Milinkovich, Excutive Director der Eclipse Foundation sowie Prof. Dr. Helten, Präsident des Bayerischen Finanz Zentrums
(-> Agenda).

Die Resonanz auf die ersten Ankündigungen ist hervorragend, so dass ich mich auf einen gut besuchten Tag mit spannenden Vorträgen und Gesprächen am Rand freue.

Zur EID Anmeldung

OSGi on Scala slides from OSGi DevCon Europe 09 online

Heiko Seeberger — Mon, 22 Jun 2009 15:13:00 +0000

In my former blog post I reasoned about whether I should do a live demo of OSGi on Scala / ScalaModules at OSGi DevCon Europe 09. As I received very positive feedback from the community (thanx for that!) I decided to go for it. Now I just finished my short talk and everything (at least the hacking part) went fine. For those not able to attend, please find the slides (which try to give you some live feeling) at my Slidespace.