/** * 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); }
protected void increment(String key) { this.meterRegistry.counter(key).increment(); }
@Setup public void setup() { registry = new PrometheusMeterRegistry(PrometheusConfig.DEFAULT); counter = registry.counter("counter"); }
@Benchmark public void micrometerCounterTags(MicrometerState state) { state.registry.counter("dynamicTags", "key1", "value1", "key2", "value2").increment(); }
@Benchmark public int countSumWithRegistryLookup() { registry.counter("counter").increment(); return sum(); }
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()); }
DefaultRequestMetrics(MeterRegistry parent, MeterIdPrefix idPrefix) { final String requests = idPrefix.name("requests"); success = parent.counter(requests, idPrefix.tags("result", "success")); failure = parent.counter(requests, idPrefix.tags("result", "failure")); requestDuration = newTimer( parent, idPrefix.name("requestDuration"), idPrefix.tags()); requestLength = newDistributionSummary( parent, idPrefix.name("requestLength"), idPrefix.tags()); responseDuration = newTimer( parent, idPrefix.name("responseDuration"), idPrefix.tags()); responseLength = newDistributionSummary( parent, idPrefix.name("responseLength"), idPrefix.tags()); totalDuration = newTimer( parent, idPrefix.name("totalDuration"), idPrefix.tags()); }
.register(registry); this.malformedSourceCounter = registry.counter(FluxMetrics.METER_MALFORMED, commonTags);
.register(registry); this.malformedSourceCounter = registry.counter(METER_MALFORMED, commonTags);
private static Counter counter( MeterRegistry meterRegistry, String interactionModel, SignalType signalType, Tag... tags) { return meterRegistry.counter( "rsocket." + interactionModel, Tags.of(tags).and("signal.type", signalType.name())); } }
/** * Creates a new {@link DuplexConnection}. * * @param connectionType the type of connection being monitored * @param delegate the {@link DuplexConnection} to delegate to * @param meterRegistry the {@link MeterRegistry} to use * @param tags additional tags to attach to {@link Meter}s * @throws NullPointerException if {@code connectionType}, {@code delegate}, or {@code * meterRegistry} is {@code null} */ MicrometerDuplexConnection( Type connectionType, DuplexConnection delegate, MeterRegistry meterRegistry, Tag... tags) { Objects.requireNonNull(connectionType, "connectionType must not be null"); this.delegate = Objects.requireNonNull(delegate, "delegate must not be null"); Objects.requireNonNull(meterRegistry, "meterRegistry must not be null"); this.close = meterRegistry.counter( "rsocket.duplex.connection.close", Tags.of(tags).and("connection.type", connectionType.name())); this.dispose = meterRegistry.counter( "rsocket.duplex.connection.dispose", Tags.of(tags).and("connection.type", connectionType.name())); this.frameCounters = new FrameCounters(connectionType, meterRegistry, tags); }
private static Counter counter( Type connectionType, MeterRegistry meterRegistry, String frameType, Tag... tags) { return meterRegistry.counter( "rsocket.frame", Tags.of(tags).and("connection.type", connectionType.name()).and("frame.type", frameType)); } }
@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")); } }
@Override public final void incrementCommandResponseDeliveredToApplication(final String tenantId) { Objects.requireNonNull(tenantId); this.registry.counter(METER_COMMANDS_RESPONSE_DELIVERED, Tags.of(MetricsTags.TAG_TENANT, tenantId)) .increment(); }
@Override public final void incrementNoCommandReceivedAndTTDExpired(final String tenantId) { Objects.requireNonNull(tenantId); this.registry.counter(METER_COMMANDS_TTD_EXPIRED, Tags.of(MetricsTags.TAG_TENANT, tenantId)) .increment(); }
@Test @DisplayName("find meters by name and type matching a subset of their tags") void findMetersByType(MeterRegistry registry) { Counter c1 = registry.counter("foo", "k", "v"); Counter c2 = registry.counter("bar", "k", "v", "k2", "v"); assertThat(registry.get("foo").tags("k", "v").counter()).isSameAs(c1); assertThat(registry.get("bar").tags("k", "v").counter()).isSameAs(c2); }
public void markSuccessMetrics(String roadName, long avroBytes) { Iterable<Tag> tags = singleton(Tag.of(ROAD, roadName)); registry.counter("onramp.send-success", tags).increment(); DistributionSummary .builder("onramp.message-size") .tags(tags) .publishPercentileHistogram() .register(registry) .record(avroBytes); }
@Test @DisplayName("find meters by name and value") void findMetersByValue(MeterRegistry registry) { Counter c = registry.counter("counter"); c.increment(); Timer t = registry.timer("timer"); t.record(10, TimeUnit.NANOSECONDS); clock(registry).add(step()); assertThat(registry.get("counter").counter().count()).isEqualTo(1.0); assertThat(registry.get("timer").timer().count()).isEqualTo(1L); assertThat(registry.get("timer").timer().totalTime(TimeUnit.NANOSECONDS)).isEqualTo(10.0); }