PhillyETE Screencast #18 - Scaling out with Akka Actors - Joshua Suereth - Chariot Solutions. From the abstract: “Erlang has made popular the notation of asynchronous message passing as means of distribution and Scaling.
While the idea of “actors” is fundamentally simple, how do we, the software engineers, make use of this abstraction to develop real life, scalable systems? This talk designs a scalable distributed search service using Akka and Scala using the “zen” of Actor based design. It covers the practical aspects of how to scale out with akka’s new experimental clustering API. We’ll investigate how to dynamically determine when to further shard an application and how to rebalance a distributed system when adding new nodes to a cluster. We’ll cover Akka-specific concepts and APIs, like partitions and cluster membership events.” Tags: 2013, actors, akka, ete2013, frameworks, joshua suereth, phillyete, scala, scalability, typesafe.
Knoldus/AkkaKnolX. Knoldus/AkkaFutures. Knoldus/akka-roller. Knoldus/akka-mini. Publish/Subscribe using Scala and Akka EventBus. This post in the second in a series on implementing publish/subscribe with Akka and Scala.
The first post, Publish/Subscribe using Scala and Akka EventStream covers some facets of Scala and Akka that'll be skipped over in this article, so it may be worth a look if things aren't clear. In Akka based publish/subscribe systems, publishers post messages to an event bus, and subscribers register subscriptions with that event bus. The bus takes care of filtering messages and delivering specific messages to those who have registered an interest in the channel that message is published to. Subscribers can register or deregister their subscriptions for any particular channel(s) at any time. In this article we'll implement an event bus using lookup classifiers with subchannel classification.
Just give me the code: GitHub Subchannel Classification Enough of that. SCEventBus.scala Please explain. There’s a lot of stuff going on in the background which requires this type aliasing. RayRoestenburg/scala-io-exercise-1. AspectJ with Akka and Scala. Imagine that you need to find out how your actors are performing, but without using the Typesafe Console.
(You don’t actually want to use this code in production, but it is an interesting project to learn.) What we are interested in is intercepting the receiveMessage call of the ActorCell class. We could roll our own build of Akka, but that is not a good idea. Instead, we would like to somehow modify the bytecode of the existing Akka JARs to include our instrumentation code. It turns out that we can use aspect oriented programming to implement cross-cutting concerns in our code. Cross-cutting concerns are pieces of code that cut across the object hierarchy; in other words, we inject the same functionality to different levels of our class structure. 1.class A { 2. def foo: Int = 42 4.class B { 5. def bar: Int = 42 7.class AA extends A. Eigengo/monitor. Scala-akka-monitoring/src/akka/actor/AkkaSampling.scala at master · vatel/scala-akka-monitoring.
Getting Started. Getting Started will guide you through the process of adding Metrics to an existing application.
We’ll go through the various measuring instruments that Metrics provides, how to use them, and when they’ll come in handy. Setting Up Maven Just add the metrics-core library as a dependency: <dependencies><dependency><groupId>com.codahale.metrics</groupId><artifactId>metrics-core</artifactId><version>${metrics.version}</version></dependency></dependencies> Note Make sure you have a metrics.version property declared in your POM with the current version, which is 3.0.1. Now it’s time to add some metrics to your application! The Registry The centerpiece of Metrics is the MetricRegistry class, which is the container for all your application’s metrics.
Monitoring Akka. In this post, I will show you how to monitor your Akka application in Datadog.
The code is now available in the latest snapshot of our monitoring project; you can include it in your Akka applications and try everything out for yourselves. The monitoring that this tool provides is not on the same level as the insight into your Akka application you get from the Typesafe Console. Use the Typesafe Console in development, when you really need to lift the hood of the actor system. Use our monitor to keep an eye on a debugged, tuned Akka system that is running in production. Imagine being able to see a chart like this: In production, you may want to monitor the actors’ queues, the number of messages they process, the performance of the receive function and error rates. When you execute this application, and issue a few go commands; and a few integers to be sure, its foo and bar actors are going to keep passing the messages between each other. The monitor structure Datadog Gallery. Kamon - Tools for Reactive Applications Monitoring.
Introduction » What is spray? Spray is a suite of lightweight Scala libraries providing client- and server-side REST/HTTP support on top Akka.
We believe that, having chosen Scala (and possibly Akka) as primary tools for building software, you’ll want to rely on their power not only in your application layer but throughout the full (JVM-level) network stack. spray provides just that: a set of integrated components for all your REST/HTTP needs that let you work with idiomatic Scala (and Akka) APIs at the stack level of your choice, all implemented without any wrapping layers around “legacy” Java libraries. Since its inception in early 2011 sprays development has been driven with a clear focus on providing tools for building integration layers rather than application cores.
As such it regards itself as a suite of libraries rather than a framework. A framework, as we’d like to think of the term, gives you a “frame”, in which you build your application. Patriknw (Patrik Nordwall)