import io.micrometer.core.instrument.Counter; //导入依赖的package包/类
MetricsTurboFilter(MeterRegistry registry, Iterable<Tag> tags) {
    errorCounter = Counter.builder("logback.events")
        .tags(tags).tags("level", "error")
        .description("Number of error level events that made it to the logs")
        .register(registry);

    warnCounter = Counter.builder("logback.events")
        .tags(tags).tags("level", "warn")
        .description("Number of warn level events that made it to the logs")
        .register(registry);

    infoCounter = Counter.builder("logback.events")
        .tags(tags).tags("level", "info")
        .description("Number of info level events that made it to the logs")
        .register(registry);

    debugCounter = Counter.builder("logback.events")
        .tags(tags).tags("level", "debug")
        .description("Number of debug level events that made it to the logs")
        .register(registry);

    traceCounter = Counter.builder("logback.events")
        .tags(tags).tags("level", "trace")
        .description("Number of trace level events that made it to the logs")
        .register(registry);
}
 

import io.micrometer.core.instrument.Counter; //导入依赖的package包/类
@Test
@DisplayName("increment by a non-negative amount")
default void incrementAmount(MeterRegistry registry) {
    Counter c = registry.counter("myCounter");
    c.increment(2);
    c.increment(0);
    clock(registry).add(step());

    assertEquals(2L, c.count());
}
 

import io.micrometer.core.instrument.Counter; //导入依赖的package包/类
public static void main(String[] args) {
    MeterRegistry registry = SampleConfig.myMonitoringSystem();

    AtomicInteger n = new AtomicInteger(0);

    FunctionCounter.builder("my.fcounter", n, AtomicInteger::get)
        .baseUnit("happiness")
        .description("A counter derived from a monotonically increasing value")
        .register(registry);

    Counter counter = Counter.builder("my.counter")
        .baseUnit("happiness")
        .description("A normal counter")
        .register(registry);

    Flux.interval(Duration.ofMillis(10))
        .doOnEach(i -> {
            n.incrementAndGet();
            counter.increment();
        })
        .blockLast();
}
 

import io.micrometer.core.instrument.Counter; //导入依赖的package包/类
public static void main(String[] args) {
    MeterRegistry registry = SampleConfig.myMonitoringSystem();
    Counter counter = registry.counter("counter");

    AtomicInteger n = new AtomicInteger(0);
    registry.more().counter("fcounter", emptyList(), n);

    RandomEngine r = new MersenneTwister64(0);
    Normal dist = new Normal(0, 1, r);

    Flux.interval(Duration.ofMillis(10))
            .doOnEach(d -> {
                if (dist.nextDouble() + 0.1 > 0) {
                    counter.increment();
                    n.incrementAndGet();
                }
            })
            .blockLast();
}
 

import io.micrometer.core.instrument.Counter; //导入依赖的package包/类
DataSourceMetricsHolder(String dataSourceName, DataSourcePoolMetadata poolMetadata, MeterRegistry registry) {
    connectionObtainTimer = Timer.builder("data.source.connections.wait")
            .tags("pool", dataSourceName)
            .register(registry);

    connectionUsageTimer = Timer.builder("data.source.connections.usage")
            .tags("pool", dataSourceName)
            .register(registry);

    connectionCreatedCounter = Counter.builder("data.source.connections.created")
            .tags("pool", dataSourceName)
            .register(registry);

    connectionFailedCounter = Counter.builder("data.source.connections.failed")
            .tags("pool", dataSourceName)
            .register(registry);

    Gauge.builder("data.source.connections.active", this, metrics -> activeConnections.doubleValue())
            .tags("pool", dataSourceName)
            .register(registry);

    Gauge.builder("data.source.connections.pending", this, metrics -> pendingConnections.doubleValue())
            .tags("pool", dataSourceName)
            .register(registry);

    if (poolMetadata != null) {
        Gauge.builder("data.source.connections.max", this, metrics -> poolMetadata.getMax())
                .tags("pool", dataSourceName)
                .register(registry);

        Gauge.builder("data.source.connections.min", this, metrics -> poolMetadata.getMin())
                .tags("pool", dataSourceName)
                .register(registry);
    }
}
 

import io.micrometer.core.instrument.Counter; //导入依赖的package包/类
@Override
Counter registerNewMeter(MeterRegistry registry) {
    return Counter.builder(getId().getName())
                  .tags(getId().getTags())
                  .description(getId().getDescription())
                  .baseUnit(getId().getBaseUnit())
                  .register(registry);
}
 

import io.micrometer.core.instrument.Counter; //导入依赖的package包/类
@DisplayName("multiple increments are maintained")
@Test
default void increment(MeterRegistry registry) {
    Counter c = registry.counter("myCounter");
    c.increment();
    clock(registry).add(step());
    assertThat(c.count()).isEqualTo(1.0, offset(1e-12));
    c.increment();
    c.increment();
    clock(registry).add(step());

    // in the case of a step aggregating system will be 2, otherwise 3
    assertThat(c.count()).isGreaterThanOrEqualTo(2.0);
}
 

import io.micrometer.core.instrument.Counter; //导入依赖的package包/类
ProteusMetricsSubscriber(CoreSubscriber<? super T> actual, Counter success, Counter error, Counter cancelled, Timer timer) {
  this.actual = actual;
  this.success = success;
  this.error = error;
  this.cancelled = cancelled;
  this.timer = timer;
}
 

import io.micrometer.core.instrument.Counter; //导入依赖的package包/类
@Bean
@ConditionalOnBean(MeterRegistry.class)
public SpanMetricReporter spanReporterCounterService(SleuthMetricProperties sleuthMetricProperties,
		MeterRegistry meterRegistry) {
	Counter acceptedSpansCounter = Counter.builder(
			sleuthMetricProperties.getSpan().getAcceptedName()).register(meterRegistry);
	Counter droppedSpansCounter = Counter.builder(
			sleuthMetricProperties.getSpan().getDroppedName()).register(meterRegistry);
	return new CounterServiceBasedSpanMetricReporter(acceptedSpansCounter, droppedSpansCounter);
}
 

import io.micrometer.core.instrument.Counter; //导入依赖的package包/类
@Test
public void shouldIncreaseNumberOfAcceptedSpans() {
	Span context = this.tracer.createSpan("http:foo");
	this.tracer.close(context);
	this.listener.poll();

	Optional<Counter> counter = this.meterRegistry.find("counter.span.accepted")
			.counter();
	then(counter.isPresent()).isTrue();
	// TODO: Can't make this work in tests
	//then(counter.get().count()).isGreaterThan(0d);
}
 

import io.micrometer.core.instrument.Counter; //导入依赖的package包/类
@Test
public void shouldIncrement() throws Exception {
	MeterRegistry meterRegistry = mock(MeterRegistry.class);
	CounterFactory factory = new DefaultCounterFactory(meterRegistry);

	Counter counter = mock(Counter.class);
	when(meterRegistry.counter(NAME)).thenReturn(counter);

	factory.increment(NAME);

	verify(counter).increment();
}
 

import io.micrometer.core.instrument.Counter; //导入依赖的package包/类
@Override
Counter newNoopMeter() {
    return new NoopCounter(getId());
}
 

import io.micrometer.core.instrument.Counter; //导入依赖的package包/类
SpectatorCounter(Meter.Id id, com.netflix.spectator.api.Counter counter) {
    super(id);
    this.counter = counter;
}
 

import io.micrometer.core.instrument.Counter; //导入依赖的package包/类
protected void doStoreFeedbackMetrics(Feedback feedback, PredictiveUnitState state){
	Counter.builder("seldon_api_model_feedback_reward").tags(tagsProvider.getModelMetrics(state)).register(Metrics.globalRegistry).increment(feedback.getReward());
	Counter.builder("seldon_api_model_feedback").tags(tagsProvider.getModelMetrics(state)).register(Metrics.globalRegistry).increment();
}
 

import io.micrometer.core.instrument.Counter; //导入依赖的package包/类
public CounterServiceBasedSpanMetricReporter(Counter acceptedSpansCounter,
		Counter droppedSpansCounter) {
	this.acceptedSpansCounter = acceptedSpansCounter;
	this.droppedSpansCounter = droppedSpansCounter;
}
 

import io.micrometer.core.instrument.Counter; //导入依赖的package包/类
@Override
public Counter success() {
    return success;
}
 

import io.micrometer.core.instrument.Counter; //导入依赖的package包/类
@Override
public Counter failure() {
    return failure;
}
 

import io.micrometer.core.instrument.Counter; //导入依赖的package包/类
@Override
protected Counter newCounter(Id id) {
    return new NoopCounter(id);
}