Registry

Meters in Micrometer are created from and held in a MeterRegistry. Each supported monitoring system has an implementation of MeterRegistry. How a registry is created varies for each implementation.

Micrometer includes a SimpleMeterRegistry that holds the latest value of each meter in memory and does not export the data anywhere. If you do not yet have a preferred monitoring system, you can get started playing with metrics by using the simple registry:

MeterRegistry registry = new SimpleMeterRegistry();

A SimpleMeterRegistry is autowired for you in Spring-based applications.

Composite Registries

Micrometer provides a CompositeMeterRegistry to which you can add multiple registries, letting you publish metrics to more than one monitoring system simultaneously:

CompositeMeterRegistry composite = new CompositeMeterRegistry();

Counter compositeCounter = composite.counter("counter");
compositeCounter.increment(); (1)

SimpleMeterRegistry simple = new SimpleMeterRegistry();
composite.add(simple); (2)

compositeCounter.increment(); (3)

1	Increments are NOOP’d until there is a registry in the composite. The counter’s count still yields 0 at this point.
2	A counter named `counter` is registered to the simple registry.
3	The simple registry counter is incremented, along with counters for any other registries in the composite.

Global Registry

Micrometer provides a static global registry called Metrics.globalRegistry and a set of static builders for generating meters based on this registry (note that globalRegistry is a composite registry):

class MyComponent {
    Counter featureCounter = Metrics.counter("feature", "region", "test"); (1)

    void feature() {
        featureCounter.increment();
    }

    void feature2(String type) {
        Metrics.counter("feature.2", "type", type).increment(); (2)
    }
}

class MyApplication {
    void start() {
        // wire your monitoring system to global static state
        Metrics.addRegistry(new SimpleMeterRegistry()); (3)
    }
}

1	Wherever possible (and especially where instrumentation performance is critical), store `Meter` instances in fields to avoid a lookup on their name or tags on each use.
2	When tags need to be determined from local context, you have no choice but to construct or lookup the Meter inside your method body. The lookup cost is just a single hash lookup, so it is acceptable for most use cases.
3	It is OK to add registries after meters have been created with code like `Metrics.counter(…)`. These meters are added to each registry, as it is bound to the global composite.