@Bean
public MeterRegistryCustomizer meterRegistryCustomizer() {
  return registry ->
      registry
          .config()
          .meterFilter(
              MeterFilter.deny(
                  id -> {
                    String uri = id.getTag("uri");
                    return uri != null
                        && (uri.startsWith("/actuator")
                            || uri.startsWith("/metrics")
                            || uri.startsWith("/health")
                            || uri.startsWith("/favicon.ico")
                            || uri.startsWith("/prometheus"));
                  }));
}
 

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;
}
 

protected JettyClientMetrics(MeterRegistry registry, JettyClientTagsProvider tagsProvider, String timingMetricName, String contentSizeMetricName, int maxUriTags) {
    this.registry = registry;
    this.tagsProvider = tagsProvider;
    this.timingMetricName = timingMetricName;
    this.contentSizeMetricName = contentSizeMetricName;

    MeterFilter timingMetricDenyFilter = new OnlyOnceLoggingDenyMeterFilter(
            () -> String.format("Reached the maximum number of URI tags for '%s'.", timingMetricName));
    MeterFilter contentSizeMetricDenyFilter = new OnlyOnceLoggingDenyMeterFilter(
            () -> String.format("Reached the maximum number of URI tags for '%s'.", contentSizeMetricName));
    registry.config()
            .meterFilter(MeterFilter.maximumAllowableTags(
                    this.timingMetricName, "uri", maxUriTags, timingMetricDenyFilter))
            .meterFilter(MeterFilter.maximumAllowableTags(
                    this.contentSizeMetricName, "uri", maxUriTags, contentSizeMetricDenyFilter));
}
 

@Test
void meterFiltersAreOnlyAppliedOnceToHistogramsAndPercentiles() {
    MeterRegistry registry = new SimpleMeterRegistry();

    registry.config().meterFilter(new MeterFilter() {
        @Override
        public Meter.Id map(Meter.Id id) {
            return id.withName("MYPREFIX." + id.getName());
        }
    });

    Timer.builder("my.timer")
         .serviceLevelObjectives(Duration.ofMillis(1))
         .publishPercentiles(0.95)
         .register(registry);

    registry.get("MYPREFIX.my.timer.percentile").tag("phi", "0.95").gauge();
    registry.get("MYPREFIX.my.timer.histogram").tag("le", "0.001").gauge();
}
 

@Test
void removeMetersWithSyntheticsAffectedByMeterFilter() {
    registry.config().meterFilter(new MeterFilter() {
        @Override
        public Meter.Id map(Meter.Id id) {
            return id.withName("another.name");
        }
    });

    Timer timer = Timer.builder("my.timer")
            .publishPercentiles(0.95)
            .register(registry);

    assertThat(registry.getMeters()).hasSize(2);
    registry.remove(timer);
    assertThat(registry.getMeters()).isEmpty();
}
 

@Test
void maximumAllowableTagsWhenDifferentTagKeyShouldNotAffect() {
    MeterFilter onMaxReached = mock(MeterFilter.class);
    MeterFilter filter = MeterFilter.maximumAllowableTags("name1", "key1", 3, onMaxReached);

    Meter.Id id1 = new Meter.Id("name1", Tags.of("key1", "value1"), null, null, Meter.Type.COUNTER);
    Meter.Id id2 = new Meter.Id("name1", Tags.of("key1", "value2"), null, null, Meter.Type.COUNTER);
    Meter.Id id3 = new Meter.Id("name1", Tags.of("key1", "value3"), null, null, Meter.Type.COUNTER);
    Meter.Id id4 = new Meter.Id("name1", Tags.of("key1", "value4"), null, null, Meter.Type.COUNTER);
    Meter.Id id5 = new Meter.Id("name1", Tags.of("key2", "value5"), null, null, Meter.Type.COUNTER);

    filter.accept(id1);
    filter.accept(id2);
    filter.accept(id3);
    verifyNoInteractions(onMaxReached);

    filter.accept(id4);
    verify(onMaxReached).accept(id4);

    filter.accept(id5);
    verifyNoMoreInteractions(onMaxReached);
}
 

@Test
void maximumAllowableTagsWhenAlreadyInAllowableTagValuesShouldNotAffect() {
    MeterFilter onMaxReached = mock(MeterFilter.class);
    MeterFilter filter = MeterFilter.maximumAllowableTags("name1", "key1", 3, onMaxReached);

    Meter.Id id1 = new Meter.Id("name1", Tags.of("key1", "value1"), null, null, Meter.Type.COUNTER);
    Meter.Id id2 = new Meter.Id("name1", Tags.of("key1", "value2"), null, null, Meter.Type.COUNTER);
    Meter.Id id3 = new Meter.Id("name1", Tags.of("key1", "value3"), null, null, Meter.Type.COUNTER);
    Meter.Id id4 = new Meter.Id("name1", Tags.of("key1", "value4"), null, null, Meter.Type.COUNTER);

    filter.accept(id1);
    filter.accept(id2);
    filter.accept(id3);
    verifyNoInteractions(onMaxReached);

    filter.accept(id4);
    verify(onMaxReached).accept(id4);

    filter.accept(id1);
    verifyNoMoreInteractions(onMaxReached);
}
 

@Test
void mapThenAccept() {
    MeterRegistry registry = new SimpleMeterRegistry();

    registry.config().meterFilter(new MeterFilter() {
        @Override
        public Meter.Id map(Meter.Id id) {
            return id.withName("my.other.counter");
        }
    });

    registry.config().meterFilter(MeterFilter.acceptNameStartsWith("my.other"));
    registry.config().meterFilter(MeterFilter.deny());

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

    assertThat(registry.getMeters()).isNotEmpty();
}
 

@Test
void differentFiltersForCompositeAndChild() {
    composite.add(simple);

    simple.config().meterFilter(MeterFilter.denyNameStartsWith("deny.child"));
    composite.config().meterFilter(MeterFilter.denyNameStartsWith("deny.composite"));

    composite.counter("deny.composite");
    composite.counter("deny.child");

    assertThat(simple.find("deny.composite").meter()).isNull();
    assertThat(composite.find("deny.composite").meter()).isNull();

    assertThat(simple.find("deny.child").meter()).isNull();
    composite.get("deny.child").meter();

    // if the meter is registered directly to the child, the composite config does not take effect
    simple.counter("deny.composite");
    simple.get("deny.composite").meter();
}
 

@Test
void meterFiltersAffectServiceLevelObjectives() {
    HealthMeterRegistry registry = HealthMeterRegistry.builder(HealthConfig.DEFAULT)
            .clock(new MockClock())
            .serviceLevelObjectives(JvmServiceLevelObjectives.MEMORY)
            .serviceLevelObjectiveFilter(MeterFilter.denyNameStartsWith("jvm.pool"))
            .serviceLevelObjectiveFilter(new MeterFilter() {
                @Override
                public Meter.Id map(Meter.Id id) {
                    return id.getName().equals("jvm.gc.load") ? id.withName("jvm.collection.load") : id;
                }
            })
            .build();

    assertThat(registry.getServiceLevelObjectives().stream().map(ServiceLevelObjective::getName))
            .contains("jvm.collection.load")
            .doesNotContain("jvm.pool.memory")
            .isNotEmpty();
}
 

protected AppOpticsMeterRegistry(AppOpticsConfig config, Clock clock, ThreadFactory threadFactory, HttpSender httpClient) {
    super(config, clock);

    config().namingConvention(new AppOpticsNamingConvention());

    this.config = config;
    this.httpClient = httpClient;

    config().meterFilter(new MeterFilter() {
        @Override
        public Meter.Id map(Meter.Id id) {
            if (id.getName().startsWith("system.")) {
                return id.withName("micrometer." + id.getName());
            }
            return id;
        }
    });

    start(threadFactory);
}
 

/**
 * Configures the {@link DropwizardMeterRegistry} with Armeria's defaults. Useful when using a different
 * implementation of {@link DropwizardMeterRegistry}, e.g., a {@code JmxMeterRegistry}.
 *
 * @return the specified {@link DropwizardMeterRegistry}
 */
public static <T extends DropwizardMeterRegistry> T configureRegistry(T meterRegistry) {
    requireNonNull(meterRegistry, "meterRegistry");
    meterRegistry.config().meterFilter(new MeterFilter() {
        @Override
        public MeterFilterReply accept(Meter.Id id) {
            if (id.getName().endsWith(".percentile") && id.getTag("phi") != null) {
                return MeterFilterReply.DENY;
            }
            if (id.getName().endsWith(".histogram") && id.getTag("le") != null) {
                return MeterFilterReply.DENY;
            }
            return MeterFilterReply.NEUTRAL;
        }
    });

    meterRegistry.config().namingConvention(MoreNamingConventions.dropwizard());
    return meterRegistry;
}
 

@Bean
@ConditionalOnMissingBean
public DefaultDestinationPublishingMeterRegistry defaultDestinationPublishingMeterRegistry(
		ApplicationMetricsProperties applicationMetricsProperties,
		MetersPublisherBinding publisherBinding,
		MetricsPublisherConfig metricsPublisherConfig, Clock clock) {
	DefaultDestinationPublishingMeterRegistry registry = new DefaultDestinationPublishingMeterRegistry(
			applicationMetricsProperties, publisherBinding, metricsPublisherConfig,
			clock);

	if (StringUtils.hasText(applicationMetricsProperties.getMeterFilter())) {
		registry.config()
				.meterFilter(MeterFilter.denyUnless(id -> PatternMatchUtils
						.simpleMatch(applicationMetricsProperties.getMeterFilter(),
								id.getName())));
	}
	return registry;
}
 

@Bean
@Order(0)
public MeterFilter metricsHttpServerUriTagFilter() {
    String metricName = this.properties.getWeb().getServer().getRequestsMetricName();
    MeterFilter filter = new OnlyOnceLoggingDenyMeterFilter(() -> String
            .format("Reached the maximum number of URI tags for '%s'.", metricName));
    return MeterFilter.maximumAllowableTags(metricName, "uri",
            this.properties.getWeb().getServer().getMaxUriTags(), filter);
}
 

private static MeterFilter createMapFilter(Map<String, String> tags) {
    if (tags.isEmpty()) {
        return new MeterFilter() {
        };
    }
    Tags commonTags = Tags.of(tags.entrySet().stream()
            .map((entry) -> Tag.of(entry.getKey(), entry.getValue()))
            .collect(Collectors.toList()));
    return MeterFilter.commonTags(commonTags);
}
 

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;
}
 

/**
 * Filter for "[PREFIX]_*"
 *
 * @param id
 * @return MeterFilterReply
 */
public MeterFilterReply accept(Meter.Id id) {
    if (!k8sMetricsProperties.isEnableCommonMetricsFilter()) {
        return MeterFilter.super.accept(id);
    }

    String metricName = id.getName();

    Boolean enabled = lookupWithFallbackToAll(this.properties.getEnable(), id, null);
    if (enabled != null) {
        return enabled ? MeterFilterReply.NEUTRAL : MeterFilterReply.DENY;
    }

    if (whitelist.contains(metricName)) {
        return MeterFilterReply.NEUTRAL;
    }
    if (blacklist.contains(metricName)) {
        return MeterFilterReply.DENY;
    }

    for(String prefix: prefixes) {
        if (metricName.startsWith(prefix)) {
            return MeterFilterReply.ACCEPT;
        }
    }

    for(String key: tagRules.keySet()) {
        String expectedValue = tagRules.get(key);
        if (expectedValue != null) {
            if (expectedValue.equals(id.getTag(key))) {
                return MeterFilterReply.ACCEPT;
            }
        }
    }

    return MeterFilterReply.DENY;
}
 

/**
 * Filter for "[PREFIX]_*"
 *
 * @param id
 * @return MeterFilterReply
 */
public MeterFilterReply accept(Meter.Id id) {
    if (!k8sMetricsProperties.isEnableCommonMetricsFilter()) {
        return MeterFilter.super.accept(id);
    }

    String metricName = id.getName();

    Boolean enabled = lookupWithFallbackToAll(this.properties.getEnable(), id, null);
    if (enabled != null) {
        return enabled ? MeterFilterReply.NEUTRAL : MeterFilterReply.DENY;
    }

    if (whitelist.contains(metricName)) {
        return MeterFilterReply.NEUTRAL;
    }
    if (blacklist.contains(metricName)) {
        return MeterFilterReply.DENY;
    }

    for(String prefix: prefixes) {
        if (metricName.startsWith(prefix)) {
            return MeterFilterReply.ACCEPT;
        }
    }

    for(String key: tagRules.keySet()) {
        String expectedValue = tagRules.get(key);
        if (expectedValue != null) {
            if (expectedValue.equals(id.getTag(key))) {
                return MeterFilterReply.ACCEPT;
            }
        }
    }

    return MeterFilterReply.DENY;
}
 

@Bean
@Order(0)
public MeterFilter metricsHttpServerUriTagFilter(MetricsProperties properties) {
    String metricName = properties.getWeb().getServer().getRequestsMetricName();
    MeterFilter filter = new OnlyOnceLoggingDenyMeterFilter(() -> String
            .format("Reached the maximum number of URI tags for '%s'.", metricName));
    return MeterFilter.maximumAllowableTags(metricName, "uri",
            properties.getWeb().getServer().getMaxUriTags(), filter);
}
 

private static MeterFilter createMapFilter(Map<String, String> tags) {
    if (tags.isEmpty()) {
        return new MeterFilter() {
        };
    }
    Tags commonTags = Tags.of(tags.entrySet().stream()
            .map((entry) -> Tag.of(entry.getKey(), entry.getValue()))
            .collect(Collectors.toList()));
    return MeterFilter.commonTags(commonTags);
}
 

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;
}
 

/**
 * Filter for "[PREFIX]_*"
 *
 * @param id
 * @return MeterFilterReply
 */
public MeterFilterReply accept(Meter.Id id) {
    if (!k8sMetricsProperties.isEnableCommonMetricsFilter()) {
        return MeterFilter.super.accept(id);
    }

    String metricName = id.getName();

    Boolean enabled = lookupWithFallbackToAll(this.properties.getEnable(), id, null);
    if (enabled != null) {
        return enabled ? MeterFilterReply.NEUTRAL : MeterFilterReply.DENY;
    }

    if (whitelist.contains(metricName)) {
        return MeterFilterReply.NEUTRAL;
    }
    if (blacklist.contains(metricName)) {
        return MeterFilterReply.DENY;
    }

    for(String prefix: prefixes) {
        if (metricName.startsWith(prefix)) {
            return MeterFilterReply.ACCEPT;
        }
    }

    for(String key: tagRules.keySet()) {
        String expectedValue = tagRules.get(key);
        if (expectedValue != null) {
            if (expectedValue.equals(id.getTag(key))) {
                return MeterFilterReply.ACCEPT;
            }
        }
    }

    return MeterFilterReply.DENY;
}
 

/**
 * Filter for "[PREFIX]_*"
 *
 * @param id
 * @return MeterFilterReply
 */
public MeterFilterReply accept(Meter.Id id) {
    if (!k8sMetricsProperties.isEnableCommonMetricsFilter()) {
        return MeterFilter.super.accept(id);
    }

    String metricName = id.getName();

    Boolean enabled = lookupWithFallbackToAll(this.properties.getEnable(), id, null);
    if (enabled != null) {
        return enabled ? MeterFilterReply.NEUTRAL : MeterFilterReply.DENY;
    }

    if (whitelist.contains(metricName)) {
        return MeterFilterReply.NEUTRAL;
    }
    if (blacklist.contains(metricName)) {
        return MeterFilterReply.DENY;
    }

    for(String prefix: prefixes) {
        if (metricName.startsWith(prefix)) {
            return MeterFilterReply.ACCEPT;
        }
    }

    for(String key: tagRules.keySet()) {
        String expectedValue = tagRules.get(key);
        if (expectedValue != null) {
            if (expectedValue.equals(id.getTag(key))) {
                return MeterFilterReply.ACCEPT;
            }
        }
    }

    return MeterFilterReply.DENY;
}
 

public void useMicrometerFilters() {
  MeterRegistry registry = BackendRegistries.getDefaultNow();
  Pattern pattern = Pattern.compile("/foo/bar/.*");

  registry.config().meterFilter(
    MeterFilter.replaceTagValues(Label.HTTP_PATH.toString(), actualPath -> {
      Matcher m = pattern.matcher(actualPath);
      if (m.matches()) {
        return "/foo/bar/:id";
      }
      return actualPath;
    }, ""));
}
 

private static MeterFilter replaceTagValues(MetricsDomain domain, String tagKey, Function<String, String> replacement) {
  return new MeterFilter() {
    @Override
    public Meter.Id map(Meter.Id id) {
      if (domain != null && !id.getName().startsWith(domain.getPrefix())) {
        return id;
      }
      return MeterFilter.replaceTagValues(tagKey, replacement).map(id);
    }
  };
}
 

@Before
public void setUp(TestContext ctx) {
  vertx = Vertx.vertx(new VertxOptions().setMetricsOptions(new MicrometerMetricsOptions()
      .setPrometheusOptions(new VertxPrometheusOptions().setEnabled(true))
    .addDisabledMetricsCategory(MetricsDomain.EVENT_BUS)
    .addLabels(Label.LOCAL, Label.REMOTE)
    .setRegistryName(registryName)
    .setEnabled(true)))
    .exceptionHandler(ctx.exceptionHandler());

  // Filter out remote labels
  BackendRegistries.getNow(registryName).config().meterFilter(
    MeterFilter.replaceTagValues(Label.REMOTE.toString(), s -> "_", "localhost:9194"));

  // Setup server
  Async serverReady = ctx.async();
  vertx.deployVerticle(new AbstractVerticle() {
    @Override
    public void start(Promise<Void> future) throws Exception {
      netServer = vertx.createNetServer();
      netServer
        .connectHandler(socket -> socket.handler(buffer -> socket.write(SERVER_RESPONSE)))
        .listen(9194, "localhost", r -> {
          if (r.failed()) {
            ctx.fail(r.cause());
          } else {
            serverReady.complete();
          }
        });
    }
  });
  serverReady.awaitSuccess();
}
 

/**
 * @return An accept filter that accepts any meter that matches this search.
 * @since 1.6.0
 */
public MeterFilter acceptFilter() {
    return new MeterFilter() {
        @Override
        public MeterFilterReply accept(Meter.Id id) {
            if (!nameMatches.test(id.getName())) {
                return MeterFilterReply.NEUTRAL;
            }

            boolean requiredKeysPresent = true;
            if (!requiredTagKeys.isEmpty()) {
                final List<String> tagKeys = new ArrayList<>();
                id.getTags().forEach(t -> tagKeys.add(t.getKey()));
                requiredKeysPresent = tagKeys.containsAll(requiredTagKeys);
            }

            boolean tagPredicatesMatched = true;
            if (!tagMatches.isEmpty()) {
                final Set<String> matchingTagKeys = new HashSet<>();
                id.getTags().forEach(t -> {
                    Collection<Predicate<String>> tagValueMatchers = tagMatches.get(t.getKey());
                    if (tagValueMatchers != null) {
                        if (tagValueMatchers.stream().allMatch(matcher -> matcher.test(t.getValue()))) {
                            matchingTagKeys.add(t.getKey());
                        }
                    }
                });
                tagPredicatesMatched = tagMatches.keySet().size() == matchingTagKeys.size();
            }

            return requiredKeysPresent && tagPredicatesMatched && id.getTags().containsAll(tags) ?
                    MeterFilterReply.ACCEPT : MeterFilterReply.NEUTRAL;
        }
    };
}
 

private Id getMappedId(Id id) {
    if (id.syntheticAssociation() != null) {
        return id;
    }
    Id mappedId = id;
    for (MeterFilter filter : filters) {
        mappedId = filter.map(mappedId);
    }
    return mappedId;
}
 

private boolean accept(Meter.Id id) {
    for (MeterFilter filter : filters) {
        MeterFilterReply reply = filter.accept(id);
        if (reply == MeterFilterReply.DENY) {
            return false;
        } else if (reply == MeterFilterReply.ACCEPT) {
            return true;
        }
    }
    return true;
}