io.micrometer.core.instrument.binder.MeterBinder Java Examples

@Override
protected void configure() {
  Multibinder<MeterBinder> meterMultibinder =
      Multibinder.newSetBinder(binder(), MeterBinder.class);

  meterMultibinder.addBinding().to(WorkspaceActivityMeterBinder.class);
  meterMultibinder.addBinding().to(WorkspaceFailureMeterBinder.class);
  meterMultibinder.addBinding().to(WorkspaceStartTrackerMeterBinder.class);
  meterMultibinder.addBinding().to(WorkspaceStopTrackerMeterBinder.class);
  meterMultibinder.addBinding().to(WorkspaceSuccessfulStartAttemptsMeterBinder.class);
  meterMultibinder.addBinding().to(WorkspaceSuccessfulStopAttemptsMeterBinder.class);
  meterMultibinder.addBinding().to(WorkspaceStartAttemptsMeterBinder.class);
  meterMultibinder.addBinding().to(UserMeterBinder.class);
  meterMultibinder.addBinding().to(RuntimeLogMeterBinder.class);
  meterMultibinder.addBinding().to(WorkspaceMeterBinder.class);
}
 

private MeterRegistryConfigurer getConfigurer() {
    if (this.configurer == null) {
        Collection<MeterBinder> meterBinders = Collections.emptyList();
        Collection<MeterFilter> meterFilters = Collections.emptyList();
        Collection<MeterRegistryCustomizer<?>> meterRegistryCustomizers = Collections.emptyList();
        MetricsProperties properties = beanFactory.getBean(MetricsProperties.class);
        if (beanFactory instanceof ListableBeanFactory) {
            ListableBeanFactory listableBeanFactory = (ListableBeanFactory)beanFactory;
            meterBinders = listableBeanFactory.getBeansOfType(MeterBinder.class).values();
            meterFilters = listableBeanFactory.getBeansOfType(MeterFilter.class).values();
            Map<String, MeterRegistryCustomizer> map = listableBeanFactory.getBeansOfType(MeterRegistryCustomizer.class);
            meterRegistryCustomizers = new ArrayList<>();
            for(MeterRegistryCustomizer c : map.values()) {
                meterRegistryCustomizers.add(c);
            }
        }
        this.configurer = new MeterRegistryConfigurer(
                meterBinders,
                meterFilters,
                meterRegistryCustomizers, properties.isUseGlobalRegistry());
    }
    return this.configurer;
}
 

private MeterRegistryConfigurer getConfigurer() {
    if (this.configurer == null) {
        Collection<MeterBinder> meterBinders = Collections.emptyList();
        Collection<MeterFilter> meterFilters = Collections.emptyList();
        Collection<MeterRegistryCustomizer<?>> meterRegistryCustomizers = Collections.emptyList();
        MetricsProperties properties = beanFactory.getBean(MetricsProperties.class);
        if (beanFactory instanceof ListableBeanFactory) {
            ListableBeanFactory listableBeanFactory = (ListableBeanFactory)beanFactory;
            meterBinders = listableBeanFactory.getBeansOfType(MeterBinder.class).values();
            meterFilters = listableBeanFactory.getBeansOfType(MeterFilter.class).values();
            Map<String, MeterRegistryCustomizer> map = listableBeanFactory.getBeansOfType(MeterRegistryCustomizer.class);
            meterRegistryCustomizers = new ArrayList<>();
            for(MeterRegistryCustomizer c : map.values()) {
                meterRegistryCustomizers.add(c);
            }
        }
        this.configurer = new MeterRegistryConfigurer(
                meterBinders,
                meterFilters,
                meterRegistryCustomizers, properties.isUseGlobalRegistry());
    }
    return this.configurer;
}
 

MeterRegistryConfigurer(Collection<MeterBinder> binders,
                        Collection<MeterFilter> filters,
                        Collection<MeterRegistryCustomizer<?>> customizers,
                        boolean addToGlobalRegistry) {
    this.binders = (binders != null ? binders : Collections.emptyList());
    this.filters = (filters != null ? filters : Collections.emptyList());
    this.customizers = (customizers != null ? customizers : Collections.emptyList());
    this.addToGlobalRegistry = addToGlobalRegistry;
}
 

@Bean
@ConditionalOnBean(MeterRegistry.class)
@ConditionalOnMissingBean(KafkaBinderMetrics.class)
public MeterBinder kafkaBinderMetrics(
		KafkaMessageChannelBinder kafkaMessageChannelBinder,
		KafkaBinderConfigurationProperties configurationProperties,
		MeterRegistry meterRegistry) {

	return new KafkaBinderMetrics(kafkaMessageChannelBinder,
			configurationProperties, null, meterRegistry);
}
 

@Bean
public MeterBinder kafkaBinderMetrics(
		KafkaMessageChannelBinder kafkaMessageChannelBinder,
		KafkaBinderConfigurationProperties configurationProperties,
		ConfigurableApplicationContext context) {

	MeterRegistry meterRegistry = context.getBean("outerContext", ApplicationContext.class)
			.getBean(MeterRegistry.class);
	return new KafkaBinderMetrics(kafkaMessageChannelBinder,
			configurationProperties, null, meterRegistry);
}
 

@Test
public void testKafkaBinderMetricsWhenNoMicrometer() {
	new ApplicationContextRunner().withUserConfiguration(KafkaMetricsTestConfig.class)
			.withClassLoader(new FilteredClassLoader("io.micrometer.core"))
			.run(context -> {
				assertThat(context.getBeanNamesForType(MeterRegistry.class))
						.isEmpty();
				assertThat(context.getBeanNamesForType(MeterBinder.class)).isEmpty();

				DirectFieldAccessor channelBindingServiceAccessor = new DirectFieldAccessor(
						context.getBean(BindingService.class));
				@SuppressWarnings("unchecked")
				Map<String, List<Binding<MessageChannel>>> consumerBindings =
					(Map<String, List<Binding<MessageChannel>>>) channelBindingServiceAccessor
						.getPropertyValue("consumerBindings");
				assertThat(new DirectFieldAccessor(
						consumerBindings.get("input").get(0)).getPropertyValue(
								"lifecycle.messageListenerContainer.beanName"))
										.isEqualTo("setByCustomizer:input");
				assertThat(new DirectFieldAccessor(
						consumerBindings.get("input").get(0)).getPropertyValue(
								"lifecycle.beanName"))
										.isEqualTo("setByCustomizer:input");
				assertThat(new DirectFieldAccessor(
						consumerBindings.get("source").get(0)).getPropertyValue(
								"lifecycle.beanName"))
										.isEqualTo("setByCustomizer:source");

				@SuppressWarnings("unchecked")
				Map<String, Binding<MessageChannel>> producerBindings =
					(Map<String, Binding<MessageChannel>>) channelBindingServiceAccessor
						.getPropertyValue("producerBindings");

				assertThat(new DirectFieldAccessor(
						producerBindings.get("output")).getPropertyValue(
						"lifecycle.beanName"))
						.isEqualTo("setByCustomizer:output");
			});
}
 

Instant(String name, Tags tags, @Nullable String baseUnit,
        @Nullable String failedMessage, Collection<MeterBinder> requires,
        Function<Search, Search> search, Function<Search, Double> toValue) {
    super(name, tags, baseUnit, failedMessage, requires);
    this.search = search;
    this.toValue = toValue;
}
 

NumericQuery(String name, Tags tags, @Nullable String baseUnit,
             @Nullable String failedMessage, Collection<MeterBinder> requires) {
    this.name = name;
    this.tags = tags;
    this.baseUnit = baseUnit;
    this.failedMessage = failedMessage;
    this.requires = requires;
}
 

void setupMetrics(Function<R, ? extends MeterBinder> metricsCreator) {
    if (meterRegistry == null) {
        return;
    }
    if (metrics == null) {
        metrics = metricsCreator.apply(registry);
        metrics.bindTo(meterRegistry);
    }
}
 

@Test
@DirtiesContext(methodMode = DirtiesContext.MethodMode.BEFORE_METHOD)
public void whenGettingBooksFromCacheThenReturnCorrectStatistics() {
    bookService.findAll();
    bookService.findAll();
    bookService.findAll();

    bookService.findByTitle("Spring Boot in Action");
    bookService.findByTitle("Spring Boot in Action");
    bookService.findByTitle("Kotlin");
    bookService.findByTitle("Kotlin");
    bookService.findByTitle("Kotlin");

    Cache books = cacheManager.getCache("books");

    Tags expectedTag = Tags.of("app", "test");
    MeterBinder metrics = provider.getMeterBinder(books, expectedTag);

    MeterRegistry registry = new SimpleMeterRegistry();
    metrics.bindTo(registry);

    FunctionCounter hits = registry.get("cache.gets").tags(expectedTag).tag("result", "hit").functionCounter();
    FunctionCounter misses = registry.get("cache.gets").tags(expectedTag).tag("result", "miss").functionCounter();

    assertThat(hits.count()).isEqualTo(5);
    assertThat(misses.count()).isEqualTo(3);

    bookService.findAll();
    bookService.findByTitle("Kotlin");

    assertThat(hits.count()).isEqualTo(7);
    assertThat(misses.count()).isEqualTo(3);
}
 

@Test
public void whenMemcachedCacheManagerBeanThenCacheStatisticsLoaded() {
    loadContext(CacheWithMemcachedCacheManagerConfiguration.class);

    CacheMeterBinderProvider provider = this.context.getBean(
            "memcachedCacheMeterBinderProvider", CacheMeterBinderProvider.class);

    assertThat(provider).isNotNull();

    CacheManager cacheManager = this.context.getBean(CacheManager.class);
    Cache books = cacheManager.getCache("books");

    MeterBinder metrics = provider.getMeterBinder(books, expectedTag);

    MeterRegistry registry = new SimpleMeterRegistry();
    metrics.bindTo(registry);

    FunctionCounter hits = registry.get("cache.gets").tags(expectedTag).tag("result", "hit").functionCounter();
    FunctionCounter misses = registry.get("cache.gets").tags(expectedTag).tag("result", "miss").functionCounter();
    FunctionCounter puts = registry.get("cache.puts").tags(expectedTag).functionCounter();
    double availableServersCount = registry.get("available_servers_count").gauge().value();

    assertThat(hits.count()).isEqualTo(0);
    assertThat(misses.count()).isEqualTo(0);
    assertThat(puts.count()).isEqualTo(0);
    assertThat(availableServersCount).isEqualTo(1.0);

    getCacheKeyValues(books, "a", "b", "b", "c", "d", "c", "a", "a", "a", "d");

    assertThat(hits.count()).isEqualTo(6);
    assertThat(misses.count()).isEqualTo(4);
    assertThat(puts.count()).isEqualTo(0);
    assertThat(availableServersCount).isEqualTo(1.0);
}
 

MeterRegistryConfigurer(Collection<MeterBinder> binders,
                        Collection<MeterFilter> filters,
                        Collection<MeterRegistryCustomizer<?>> customizers,
                        boolean addToGlobalRegistry) {
    this.binders = (binders != null ? binders : Collections.emptyList());
    this.filters = (filters != null ? filters : Collections.emptyList());
    this.customizers = (customizers != null ? customizers : Collections.emptyList());
    this.addToGlobalRegistry = addToGlobalRegistry;
}
 

@Override
public MeterBinder getMeterBinder(Cache cache, Iterable<Tag> tags) {

   if (cache.getNativeCache() instanceof RemoteCache) {
      return new RemoteInfinispanCacheMeterBinder((RemoteCache) cache.getNativeCache(), tags);
   } else {
      return new RemoteInfinispanCacheMeterBinder(null, tags);
   }
}
 

@Override
public MeterBinder getMeterBinder(Cache cache, Iterable<Tag> tags) {
   Object nativeCache = cache.getNativeCache();
   MeterBinder meterBinder = null;
   if (nativeCache instanceof org.infinispan.Cache) {
      meterBinder = new InfinispanCacheMeterBinder((org.infinispan.Cache) nativeCache, tags);
   } else {
      if (nativeCache instanceof javax.cache.Cache){ // for caches like org.infinispan.jcache.embedded.JCache
         meterBinder = new JCacheMetrics((javax.cache.Cache) nativeCache, tags);
      }
   }
   return meterBinder;
}
 

@Override
protected void configure() {
  Multibinder<MeterBinder> meterMultibinder =
      Multibinder.newSetBinder(binder(), MeterBinder.class);

  meterMultibinder.addBinding().to(CurrentLogwatchersMeterBinder.class);
}
 

@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
protected void configureServlets() {
  Multibinder<MeterBinder> meterMultibinder =
      Multibinder.newSetBinder(binder(), MeterBinder.class);
  meterMultibinder.addBinding().toProvider(TomcatMetricsProvider.class);

  bind(Manager.class).toInstance(getManager(getServletContext()));
  filter("/*").through(ApiResponseMetricFilter.class);
}
 

@Override
public MeterBinder getMeterBinder(RedissonCache cache, Iterable<Tag> tags) {
    return new RedissonCacheMetrics(cache, tags);
}
 

@Bean
public MeterBinder executorServiceMetrics(final ExecutorService executor) {
    return new ExecutorServiceMetrics(executor, "http-example", singleton(Tag.of("clientId", "example")));
}
 

@Inject
public void bindToRegistry(
    PrometheusMeterRegistry meterRegistry, Set<MeterBinder> meterBinderList) {
  meterBinderList.forEach(e -> e.bindTo(meterRegistry));
}
 

/**
 * Returns a newly-created {@link MeterBinder} which binds the stats about this
 * {@link HealthCheckedEndpointGroup} with the default meter names.
 */
public MeterBinder newMeterBinder(String groupName) {
    return newMeterBinder(new MeterIdPrefix(Flags.useLegacyMeterNames() ? "armeria.client.endpointGroup"
                                                                        : "armeria.client.endpoint.group",
                                            "name", groupName));
}
 

@Bean
public MeterBinder processMemoryMetrics() {
    return new ProcessMemoryMetrics();
}
 

@Override
public Collection<MeterBinder> getRequires() {
    return delegate.getRequires();
}
 

@Override
public Collection<MeterBinder> getRequires() {
    return Arrays.stream(objectives)
            .flatMap(o -> o.getRequires().stream())
            .collect(Collectors.toList());
}
 

Builder(String name, @Nullable String failedMessage, Collection<MeterBinder> requires) {
    this.name = name;
    this.failedMessage = failedMessage;
    this.requires = requires;
}
 

@Override
public Collection<MeterBinder> getRequires() {
    return requires;
}
 

private void addMetric(MeterBinder meterBinder,MeterRegistry registry) {
    MetricsBinderRendererAdapter metricsBinderRendererAdapter = new MetricsBinderRendererAdapter(meterBinder);
    metricsBinderRendererAdapter.bindTo(registry);
    metricsRenderers.add(metricsBinderRendererAdapter);
}
 

@SneakyThrows
@Override
public Class<? extends MeterBinder> metricsBinderImplementation() {
    return (Class<? extends MeterBinder>) Class.forName("ai.konduit.serving.metrics.MultiLabelMetrics");
}
 

@Override
@SneakyThrows
public Class<? extends MeterBinder> metricsBinderImplementation() {
    return (Class<? extends MeterBinder>) Class.forName("ai.konduit.serving.metrics.RegressionMetrics");
}