private void setupServerMetrics() { final MeterRegistry meterRegistry = config().meterRegistry(); final GracefulShutdownSupport gracefulShutdownSupport = this.gracefulShutdownSupport; assert gracefulShutdownSupport != null; meterRegistry.gauge("armeria.server.pendingResponses", gracefulShutdownSupport, GracefulShutdownSupport::pendingResponses); meterRegistry.gauge("armeria.server.connections", connectionLimitingHandler, ConnectionLimitingHandler::numConnections); }
@Override public void accept(List<Endpoint> endpoints) { final Map<Endpoint, Boolean> endpointsToUpdate = new HashMap<>(); endpoints.forEach(e -> endpointsToUpdate.put(e, true)); endpointGroup.allServers.forEach( conn -> endpointsToUpdate.putIfAbsent(conn.endpoint(), false)); // Update the previously appeared endpoints. healthMap.entrySet().forEach(e -> { final Endpoint authority = e.getKey(); final Boolean healthy = endpointsToUpdate.remove(authority); e.setValue(Boolean.TRUE.equals(healthy)); }); // Process the newly appeared endpoints. endpointsToUpdate.forEach((endpoint, healthy) -> { healthMap.put(endpoint, healthy); final List<Tag> tags = new ArrayList<>(2); tags.add(Tag.of("authority", endpoint.authority())); final String ipAddr = endpoint.hasIpAddr() ? endpoint.ipAddr() : ""; assert ipAddr != null; tags.add(Tag.of("ip", ipAddr)); registry.gauge(idPrefix.name(), idPrefix.tags(tags), this, unused -> healthMap.get(endpoint) ? 1 : 0); }); } }
@Override public void bindTo(MeterRegistry registry) { final String count = idPrefix.name("count"); registry.gauge(count, idPrefix.tags("state", "healthy"), endpointGroup, unused -> endpointGroup.endpoints().size()); registry.gauge(count, idPrefix.tags("state", "unhealthy"), endpointGroup, unused -> endpointGroup.allServers.size() - endpointGroup.endpoints().size()); final ListenerImpl listener = new ListenerImpl(registry, idPrefix.append("healthy")); listener.accept(endpointGroup.endpoints()); endpointGroup.addListener(listener); }
CircuitBreakerMetrics(MeterRegistry parent, MeterIdPrefix idPrefix) { requireNonNull(parent, "parent"); requireNonNull(idPrefix, "idPrefix"); final String requests = idPrefix.name("requests"); parent.gauge(requests, idPrefix.tags("result", "success"), latestEventCount, lec -> lec.get().success()); parent.gauge(requests, idPrefix.tags("result", "failure"), latestEventCount, lec -> lec.get().failure()); final String transitions = idPrefix.name("transitions"); transitionsToClosed = parent.counter(transitions, idPrefix.tags("state", CLOSED.name())); transitionsToOpen = parent.counter(transitions, idPrefix.tags("state", OPEN.name())); transitionsToHalfOpen = parent.counter(transitions, idPrefix.tags("state", HALF_OPEN.name())); rejectedRequests = parent.counter(idPrefix.name("rejectedRequests"), idPrefix.tags()); }
/** * Constructs a new Micrometer metrics listener that adds metrics to the given registry with the given list of tags. * * @param meterRegistry the registry to which to add metrics * @param tags an optional collection of tags to attach to metrics; may be empty */ public MicrometerApnsClientMetricsListener(final MeterRegistry meterRegistry, final Iterable<Tag> tags) { this.notificationStartTimes = new ConcurrentHashMap<>(); this.notificationTimer = meterRegistry.timer(NOTIFICATION_TIMER_NAME, tags); this.writeFailures = meterRegistry.counter(WRITE_FAILURES_COUNTER_NAME, tags); this.sentNotifications = meterRegistry.counter(SENT_NOTIFICATIONS_COUNTER_NAME, tags); this.acceptedNotifications = meterRegistry.counter(ACCEPTED_NOTIFICATIONS_COUNTER_NAME, tags); this.rejectedNotifications = meterRegistry.counter(REJECTED_NOTIFICATIONS_COUNTER_NAME, tags); this.connectionFailures = meterRegistry.counter(CONNECTION_FAILURES_COUNTER_NAME, tags); meterRegistry.gauge(OPEN_CONNECTIONS_GAUGE_NAME, tags, openConnections); }
private static void onRequest(RequestLog log, MeterIdPrefixFunction meterIdPrefixFunction) { final RequestContext ctx = log.context(); final MeterRegistry registry = ctx.meterRegistry(); final MeterIdPrefix activeRequestsId = meterIdPrefixFunction.activeRequestPrefix(registry, log) .append("activeRequests"); final ActiveRequestMetrics activeRequestMetrics = MicrometerUtil.register( registry, activeRequestsId, ActiveRequestMetrics.class, (reg, prefix) -> reg.gauge(prefix.name(), prefix.tags(), new ActiveRequestMetrics(), ActiveRequestMetrics::doubleValue)); activeRequestMetrics.increment(); ctx.log().addListener(requestLog -> onResponse(requestLog, meterIdPrefixFunction, activeRequestMetrics), RequestLogAvailability.COMPLETE); }
CaffeineMetrics(MeterRegistry parent, MeterIdPrefix idPrefix) { this.parent = requireNonNull(parent, "parent"); this.idPrefix = requireNonNull(idPrefix, "idPrefix"); final String requests = idPrefix.name("requests"); parent.more().counter(requests, idPrefix.tags("result", "hit"), this, func(HIT_COUNT, ref -> ref.cacheStats.hitCount())); parent.more().counter(requests, idPrefix.tags("result", "miss"), this, func(MISS_COUNT, ref -> ref.cacheStats.missCount())); parent.more().counter(idPrefix.name("evictions"), idPrefix.tags(), this, func(EVICTION_COUNT, ref -> ref.cacheStats.evictionCount())); parent.more().counter(idPrefix.name("evictionWeight"), idPrefix.tags(), this, func(EVICTION_WEIGHT, ref -> ref.cacheStats.evictionWeight())); parent.gauge(idPrefix.name("estimatedSize"), idPrefix.tags(), this, func(null, ref -> ref.estimatedSize)); }
private <N extends Number> void bindDataSource(MeterRegistry registry, String metricName, Function<DataSource, N> function) { if (function.apply(this.dataSource) != null) { registry.gauge("jdbc.connections." + metricName, this.tags, this.dataSource, (m) -> function.apply(m).doubleValue()); } }
public MetricsInterceptor(MeterRegistry meterRegistry) { this.gauge = meterRegistry.gauge("github.ratelimit.remaining", new AtomicInteger(0)); }
/** * Creates a new metrics instance. * * @param registry The meter registry to use. * @throws NullPointerException if registry is {@code null}. */ public MicrometerBasedMetrics(final MeterRegistry registry) { Objects.requireNonNull(registry); this.registry = registry; this.unauthenticatedConnections = registry.gauge(METER_CONNECTIONS_UNAUTHENTICATED, new AtomicLong()); }
protected <K, V extends Number> V gaugeForKey(final String name, final Map<K, V> map, final K key, final Tags tags, final Supplier<V> instanceSupplier) { return map.computeIfAbsent(key, a -> { return this.registry.gauge(name, tags, instanceSupplier.get()); }); }
/** * Create a new metrics instance. * * @param registry The meter registry to use. * * @throws NullPointerException if either parameter is {@code null}. */ public MicrometerBasedMetrics(final MeterRegistry registry) { Objects.requireNonNull(registry); this.registry = registry; this.unauthenticatedConnections = registry.gauge("hono.connections.unauthenticated", new AtomicLong()); }
public void incrementActiveConnections() { activeConnections .computeIfAbsent(roadAndStream, x -> registry.gauge(OFFRAMP + ACTIVE_CONNECTIONS, roadStreamTags, new AtomicInteger())) .incrementAndGet(); }
private void gauge(MetricType type, AtomicInteger number) { if (meterRegistry != null) meterRegistry.gauge(type.getMetricName() + ".gauge.", number); }
@Override public <T extends Number> T gauge(String name, Iterable<Tag> tags, T number) { return meterRegistry.gauge(getName(name), tags, number); }
@Override public void bindTo(MeterRegistry registry) { if (poolMetadata != null) { registry.gauge(name + ".connections.active", tags, dataSource, dataSource -> poolMetadata.getActive() != null ? poolMetadata.getActive() : 0); registry.gauge(name + ".connections.max", tags, dataSource, dataSource -> poolMetadata.getMax()); registry.gauge(name + ".connections.min", tags, dataSource, dataSource -> poolMetadata.getMin()); } } }
@PostConstruct private void initMetrics() { if (meterRegistry != null) { histogramEventAge = Optional.of(meterRegistry.gauge("histogram.event.age", new AtomicLong(0))); meterEventsPublished = Optional.of(meterRegistry.counter("meter.events.published")); meterEventsDuplicates = Optional.of(meterRegistry.counter("meter.events.duplicates")); meterEventsRetries = Optional.of(meterRegistry.counter("meter.events.retries")); } }
@Test @DisplayName("gauges attached to an object are updated when their values are observed") default void objectGauge(MeterRegistry registry) { List<String> list = registry.gauge("my.gauge", emptyList(), new ArrayList<>(), List::size); list.addAll(Arrays.asList("a", "b")); Gauge g = registry.get("my.gauge").gauge(); assertThat(g.value()).isEqualTo(2); }
@Test @DisplayName("gauges that reference an object that is garbage collected report NaN") default void garbageCollectedSourceObject(MeterRegistry registry) { registry.gauge("my.gauge", emptyList(), (Map) null, Map::size); assertThat(registry.get("my.gauge").gauge().value()).matches(val -> val == null || Double.isNaN(val) || val == 0.0); }
@Test @DisplayName("gauges attached to a number are updated when their values are observed") default void numericGauge(MeterRegistry registry) { AtomicInteger n = registry.gauge("my.gauge", new AtomicInteger(0)); n.set(1); Gauge g = registry.get("my.gauge").gauge(); assertThat(g.value()).isEqualTo(1); n.set(2); assertThat(g.value()).isEqualTo(2); }