DOC: Updated logging documentation. See #1467

akka-docs/general/code/akka/docs/config/ConfigDocSpec.scala

@@ -0,0 +1,33 @@
+package akka.docs.config
+
+import org.scalatest.WordSpec
+import org.scalatest.matchers.MustMatchers
+
+//#imports
+import akka.actor.ActorSystem
+import com.typesafe.config.ConfigFactory
+
+//#imports
+
+class ConfigDocSpec extends WordSpec with MustMatchers {
+
+  "programmatically configure ActorSystem" in {
+    //#custom-config
+    val customConf = ConfigFactory.parseString("""
+      akka.actor.deployment {
+        /user/my-service {
+          router = round-robin
+          nr-of-instances = 3
+        }
+      }
+      """)
+    // ConfigFactory.load sandwiches customConfig between default reference
+    // config and default overrides, and then resolves it.
+    val system = ActorSystem("MySystem", ConfigFactory.load(customConf))
+    //#custom-config
+
+    system.stop()
+
+  }
+
+}

akka-docs/general/code/akka/docs/event/LoggingDocSpec.scala

@@ -0,0 +1,59 @@
+package akka.docs.event
+
+import akka.actor.ActorSystem
+import akka.testkit.AkkaSpec
+import akka.actor.Actor
+import akka.actor.Props
+
+object LoggingDocSpec {
+
+  //#my-actor
+  import akka.event.Logging
+
+  class MyActor extends Actor {
+    val log = Logging(context.system, this)
+    override def preStart() = {
+      log.debug("Starting")
+    }
+    override def preRestart(reason: Throwable, message: Option[Any]) {
+      log.error(reason, "Restarting due to [{}] when processing [{}]",
+        reason.getMessage, message.getOrElse(""))
+    }
+    def receive = {
+      case "test" ⇒ log.info("Received test")
+      case x      ⇒ log.warning("Received unknown message: {}", x)
+    }
+  }
+  //#my-actor
+
+  //#my-event-listener
+  import akka.event.Logging.InitializeLogger
+  import akka.event.Logging.LoggerInitialized
+  import akka.event.Logging.Error
+  import akka.event.Logging.Warning
+  import akka.event.Logging.Info
+  import akka.event.Logging.Debug
+
+  class MyEventListener extends Actor {
+    def receive = {
+      case InitializeLogger(_)              ⇒ sender ! LoggerInitialized
+      case Error(cause, logSource, message) ⇒ // ...
+      case Warning(logSource, message)      ⇒ // ...
+      case Info(logSource, message)         ⇒ // ...
+      case Debug(logSource, message)        ⇒ // ...
+    }
+  }
+  //#my-event-listener
+
+}
+
+class LoggingDocSpec extends AkkaSpec {
+
+  import LoggingDocSpec.MyActor
+
+  "use a logging actor" in {
+    val myActor = system.actorOf(Props(new MyActor))
+    myActor ! "test"
+  }
+
+}

akka-docs/general/code/akka/docs/event/LoggingDocTest.scala

@@ -0,0 +1,5 @@
+package akka.docs.event
+
+import org.scalatest.junit.JUnitSuite
+
+class LoggingDocTest extends LoggingDocTestBase with JUnitSuite

akka-docs/general/code/akka/docs/event/LoggingDocTestBase.java

@@ -0,0 +1,86 @@
+package akka.docs.event;
+
+//#imports
+import akka.event.Logging;
+import akka.event.LoggingAdapter;
+
+//#imports
+
+//#imports-listener
+import akka.event.Logging.InitializeLogger;
+import akka.event.Logging.Error;
+import akka.event.Logging.Warning;
+import akka.event.Logging.Info;
+import akka.event.Logging.Debug;
+
+//#imports-listener
+
+import org.junit.Test;
+
+import scala.Option;
+import static org.junit.Assert.*;
+
+import akka.actor.ActorSystem;
+import akka.actor.ActorRef;
+import akka.actor.UntypedActor;
+import akka.actor.UntypedActorFactory;
+
+public class LoggingDocTestBase {
+
+  @Test
+  public void useLoggingActor() {
+    ActorSystem system = ActorSystem.create("MySystem");
+    ActorRef myActor = system.actorOf(new UntypedActorFactory() {
+      public UntypedActor create() {
+        return new MyActor();
+      }
+    });
+    myActor.tell("test");
+    system.stop();
+  }
+
+  //#my-actor
+  class MyActor extends UntypedActor {
+    LoggingAdapter log = Logging.getLogger(getContext().system(), this);
+
+    @Override
+    public void preStart() {
+      log.debug("Starting");
+    }
+
+    @Override
+    public void preRestart(Throwable reason, Option<Object> message) {
+      log.error(reason, "Restarting due to [{}] when processing [{}]", reason.getMessage(),
+          message.isDefined() ? message.get() : "");
+    }
+
+    public void onReceive(Object message) {
+      if (message.equals("test")) {
+        log.info("Received test");
+      } else {
+        log.warning("Received unknown message: {}", message);
+      }
+    }
+  }
+
+  //#my-actor
+
+  //#my-event-listener
+  class MyEventListener extends UntypedActor {
+    public void onReceive(Object message) {
+      if (message instanceof InitializeLogger) {
+        getSender().tell(Logging.loggerInitialized());
+      } else if (message instanceof Error) {
+        // ...
+      } else if (message instanceof Warning) {
+        // ...
+      } else if (message instanceof Info) {
+        // ...
+      } else if (message instanceof Debug) {
+        // ...
+      }
+    }
+  }
+  //#my-event-listener
+
+}