DOCSEARCHbyAlgolia
Submit Docs

Micrometer Tracing

website·Indexed 38 days ago

https://docs.micrometer.io/context-propagation/reference/

Documentation for Micrometer Tracing, including guides on supported reporters, testing, and configuring with Micrometer Observation. Latest stable version is 1.7.1.

Tokens
739.7K
Snippets
3.3K
Records
4.5K
Agent score
48%

What's inside Micrometer Tracing

  1. Overview of Micrometer Observation API

    The Micrometer Observation API allows developers to instrument their code once and produce multiple types of telemetry (such as metrics, distributed tracing spans, and logs) by reacting to the lifecycle of an 'Observation'.

    Key concepts include:

    • ObservationRegistry: The central registry containing configuration, handlers, filters, and predicates.
    • ObservationHandler: Reacts to lifecycle events to create timers, spans, or logs. It only triggers if it supports the specific Observation.Context implementation.
    • Observation.Context: A mutable map attached to an Observation used to pass state between handlers without relying on thread locals.
    • ObservationConvention: Separates the lifecycle operations from the configuration (naming and metadata), allowing naming conventions to be changed without modifying instrumentation code.
    • ObservationFilter: Mutates the Context before an Observation stops (e.g., adding environment metadata).
    • ObservationPredicate: A condition used to determine if an Observation should be created or disabled.

  2. Overview of Micrometer observability facade

    Micrometer is a vendor-neutral instrumentation facade for JVM-based applications, similar to SLF4J but for observability. It allows developers to instrument code without vendor lock-in by providing a consistent interface that can be mapped to various observability backends.

  3. Overview of Micrometer Context Propagation

    The Micrometer Context Propagation library is designed to assist with the propagation of context across various context mechanisms. It enables the transfer of state between different threading models and asynchronous boundaries, specifically supporting mechanisms such as ThreadLocal and Project Reactor's Context.

  4. Overview of Micrometer observability facade

    Micrometer is a vendor-neutral instrumentation facade for JVM-based applications, similar to SLF4J but for observability. It allows developers to instrument code without vendor lock-in, enabling the application to ship data to various backends by choosing the observability system as a final step. It supports a wide range of systems including Prometheus, Datadog, New Relic, OpenTelemetry Protocol (OTLP), Azure Monitor, CloudWatch, and Google Stackdriver.

  5. Overview of Micrometer Meter Filters

    Meter filters allow developers to control how and when meters are registered and what statistics they emit. They are added to a registry programmatically and are applied in the order they are configured. Filters serve three primary purposes: denying or accepting meter registration, transforming meter IDs (names, tags, descriptions), and configuring distribution statistics.
    registry.config()
    .meterFilter(MeterFilter.ignoreTags("too.much.information"))
    .meterFilter(MeterFilter.denyNameStartsWith("jvm"));

  6. Overview of Micrometer Cache Instrumentations

    Micrometer provides bindings for popular caching libraries to monitor performance metrics, specifically cache hits and misses. Unlike basic library statistics (e.g., Guava's CacheStats) which provide lifetime totals, Micrometer uses function-tracking counters to allow developers to monitor hits and misses within specific time intervals. This enables the calculation of hit/miss ratios over time for tuning storage and load efficiency.

  7. Overview of Micrometer observability facade

    Micrometer is a vendor-neutral instrumentation facade for JVM-based applications, similar to SLF4J but for observability. It allows developers to instrument code without vendor lock-in, enabling the application to ship data to various observability backends by choosing the specific system as a final step.

  8. Overview of Micrometer Tracing

    Micrometer Tracing is a Spring-agnostic facade for popular tracer libraries, allowing JVM-based applications to be instrumented without vendor lock-in. It is designed for low overhead and high portability. Additionally, it integrates with Micrometer's ObservationHandler (introduced in Micrometer 1.10.0), ensuring that whenever an Observation is used, a corresponding span is automatically created, started, stopped, and reported.

  9. Introduction to Micrometer instrumentation facade

    Micrometer is an instrumentation facade for JVM-based applications that provides a consistent API over various observability system clients. It allows developers to instrument application code without vendor lock-in, enabling the recording of data used for observing, alerting, and reacting to the operational state of an environment.

  10. Overview of Micrometer Context Propagation abstractions

    The Micrometer Context Propagation library provides a set of abstractions to facilitate the movement of contextual values between different storage mechanisms (e.g., ThreadLocals and Reactor Context).

    Key abstractions include:

    • ThreadLocalAccessor: A contract used to access values stored in a ThreadLocal.
    • ContextAccessor: A contract used to access values stored in a Map-like context.
    • ContextRegistry: A central registry used to manage instances of ThreadLocalAccessor and ContextAccessor.
    • ContextSnapshot: A holder of contextual values that provides the mechanisms to capture values from one context and propagate them to another.

  11. Overview of Micrometer observability facade

    Micrometer is a vendor-neutral instrumentation facade for JVM-based applications, similar to how SLF4J operates for logging. It allows developers to instrument application code without vendor lock-in, enabling the application to ship metrics to various observability backends by changing the configuration at the final step rather than rewriting the instrumentation code.

  12. Overview of Micrometer Observation API

    Micrometer Observation is a component of the Micrometer project that provides an Observation API. Its primary goal is to allow developers to instrument their code a single time to receive multiple observability benefits, such as metrics and distributed tracing, without needing to implement each separately.