@Provides
@Singleton
public PrometheusMeterRegistry providePrometheusMeterRegistry(ExecutorService executorService,
                                                              @Named("systemRuntime.projectName") String projectName) {
    PrometheusMeterRegistry registry = new PrometheusMeterRegistry(PrometheusConfig.DEFAULT);
    new LogbackMetrics().bindTo(registry);
    new ClassLoaderMetrics().bindTo(registry);
    new ExecutorServiceMetrics(executorService,
            projectName + "-ExecutorService",
            () -> Tags.of(projectName, "ExecutorService").iterator()).bindTo(registry);
    new JvmMemoryMetrics().bindTo(registry);
    new JvmGcMetrics().bindTo(registry);
    new JvmThreadMetrics().bindTo(registry);
    new ProcessorMetrics().bindTo(registry);
    new ProcessMemoryMetrics().bindTo(registry);
    new ProcessThreadMetrics().bindTo(registry);
    new FileDescriptorMetrics().bindTo(registry);
    new DiskSpaceMetrics(new File("/")).bindTo(registry);
    new UptimeMetrics().bindTo(registry);

    registry.config().commonTags("instance", projectName);
    registry.config().commonTags("application", projectName);
    registry.config().commonTags("service", projectName);

    return registry;
}
 

@Issue("#411")
@Test
void counterIncrementDoesNotCauseStackOverflow() {
    registry = new StatsdMeterRegistry(configWithFlavor(StatsdFlavor.ETSY), clock);
    new LogbackMetrics().bindTo(registry);

    // Cause the processor to get into a state that would make it perform logging at DEBUG level.
    ((Logger) LoggerFactory.getLogger(Operators.class)).setLevel(Level.DEBUG);
    registry.processor.onComplete();

    registry.counter("my.counter").increment();
}
 

@Override
protected void configure() {
  bind(MetricsServer.class).asEagerSingleton();
  bind(MetricsBinder.class).asEagerSingleton();
  bind(CollectorRegistry.class).toInstance(CollectorRegistry.defaultRegistry);
  bind(PrometheusMeterRegistry.class)
      .toProvider(PrometheusMeterRegistryProvider.class)
      .asEagerSingleton();
  bind(MeterRegistry.class).to(PrometheusMeterRegistry.class);

  Multibinder<MeterBinder> meterMultibinder =
      Multibinder.newSetBinder(binder(), MeterBinder.class);
  meterMultibinder.addBinding().to(ClassLoaderMetrics.class);
  meterMultibinder.addBinding().to(JvmMemoryMetrics.class);
  meterMultibinder.addBinding().to(JvmGcMetrics.class);
  meterMultibinder.addBinding().to(JvmThreadMetrics.class);
  meterMultibinder.addBinding().to(LogbackMetrics.class);
  meterMultibinder.addBinding().to(FileDescriptorMetrics.class);
  meterMultibinder.addBinding().to(ProcessorMetrics.class);
  meterMultibinder.addBinding().to(UptimeMetrics.class);
  meterMultibinder.addBinding().to(FileStoresMeterBinder.class);
  meterMultibinder.addBinding().to(ApiResponseCounter.class);
  meterMultibinder.addBinding().to(ProcessMemoryMetrics.class);
  meterMultibinder.addBinding().to(ProcessThreadMetrics.class);

  bind(EventListener.class).toProvider(OkHttpMetricsEventListenerProvider.class);
}
 

@Override
public void complete() {
    LogbackMetrics.ignoreMetrics(delegate::complete);
}
 

@Override
public void error(Throwable e) {
    LogbackMetrics.ignoreMetrics(() -> delegate.error(e));
}
 

@Override
public FluxSink<String> next(String s) {
    LogbackMetrics.ignoreMetrics(() -> delegate.next(s));
    return this;
}
 

@Override
public FluxSink<String> onRequest(LongConsumer consumer) {
    LogbackMetrics.ignoreMetrics(() -> delegate.onRequest(consumer));
    return this;
}
 

@Override
public FluxSink<String> onCancel(Disposable d) {
    LogbackMetrics.ignoreMetrics(() -> delegate.onCancel(d));
    return this;
}
 

@Override
public FluxSink<String> onDispose(Disposable d) {
    LogbackMetrics.ignoreMetrics(() -> delegate.onDispose(d));
    return this;
}
 

@Bean
LogbackMetrics logbackMetrics() {
  return new LogbackMetrics();
}