Collect Metrics and Traces with minimal code

Battle-tested, free and open-source instrumentation for distributed systems.

Start Monitoring Free

Join hundreds of developers monitoring microservices with Kamon

Automatic Instrumentation

Setup with a few lines of code and Kamon will do the rest for you!
Kamon automatically collects metrics and traces from Akka, Play Framework and other JVM frameworks.

See available instrumentations

Instrument Once, Report Anywhere

Send metrics and traces wherever you want. Switch between Kamon APM, Prometheus, Zipkin and more at any time, without code changes.

See available reporters

Code Your Own Instrumentation

Collect your own metrics, define custom traces and propagate context with Kamon core APIs.

Metrics

Track latency, errors and any business metric with high-definition histograms.

Distributed Tracing

Trace operations through any service and application component.

Context Propagation

Propagate userID, requestID and any correlation data between threads and services.

                
                  // One-Liner metric and increment
                  Kamon.counter("app.orders")
                    .withoutTags()
                    .increment()

                  // Fully define a metric
                  val DataSent = Kamon.counter(
                    name = "network.data.sent",
                    description = "Counts data sent out",
                    unit = bytes
                  )

                  // Tag and use an instrument
                  val sentOnInterface = DataSent
                    .withTag("interface", "eth0")

                  sentOnInterface.increment(512)

Learn About Metrics

                
                  // Adding tags to the SpanBuilder
                  val span = Kamon.spanBuilder("find-users")
                    .tag("string-tag", "hello")
                    .tag("number-tag", 42)
                    .tag("boolean-tag", true)
                    .start()

                  // Adding tags to the Span.
                  span
                    .tag("other-string-tag", "bye")
                    .tag("other-number-tag", 24)
                    .tag("other-boolean-tag", false)

                  // After this point no tags can be added.
                  span.finish()

Learn About Tracing

                
                  // Creating a Context with two keys
                  val context = Context()
                    .withKey(UserID, "1234")
                    .withKey(SessionID, Some(42))

                  // Reading values from a Context
                  val userID: String = context.get(UserID)
                  val sessionID: Option[Int] = context.get(SessionID)

                  // The default value is returned for non-existent keys
                  val requestID: Option[String] = context.get(RequestID)

Learn About Context