Instrument your services and get telemetry
data that can be sent anywhere

Battle-tested, free and open source tools for
instrumenting distributed systems

Complete telemetry API

Use a single, comprehensive API to gather all the telemetry data you need from distributed systems
Metrics
Track latency, errors and any business metric with a dimensional model and high-definition histograms.
Distributed Tracing
Model operations that span several services and components - with automatically tracked metrics.
Context Propagation
Propagate information like userID, transactionID and other correlation data between threads and processes.
                
                  // One-liner
                  Kamon.counter("app.orders.sent").increment()

                  // Fully defined and refined (tagged) counter
                  val sentBytes = Kamon.counter("network.traffic", information.bytes)
                    .refine (
                      "direction" -> "out",
                      "interface" -> "eth0"
                    )

                  sentBytes.increment()
                  sentBytes.increment(512)
                
              
LEARN ABOUT METRICS
                
                  // Adding tags to the SpanBuilder
                  val span = Kamon.buildSpan("find-users")
                    .withTag("string-tag", "hello")
                    .withTag("number-tag", 42)
                    .withTag("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

Instrument your services
with minimal effort

Add a few lines of code and configuration and Kamon will do the rest for you with automatic instrumentation that collect metrics, enables distributed tracing and performs context propagation out of the box
Enabling Kamon in a Project
Some of the available integrations:
JVM
Track time spent in garbage collection, memory usage, thread pool metrics and more.
Akka
Trace messages flowing through the cluster, gather detailed metrics on actors, routers and more.
Play Framework
Trace client and server side HTTP requests and propagate context data on each call.
Kamon Interaction
Works with Prometheus, Zipkin, InfluxDB, Kamon APM
and other OSS and commercial solutions.

Instrument once,
report anywhere

Send all the metrics and trace data
wherever you want, without having to
change the instrumentation at all.
  • Enable reporters via configuration,
    change them any time you need.
  • Creating a new reporter is just about implementing an interface.
SEE ALL REPORTERS