import io.micrometer.core.instrument.Meter; //导入依赖的package包/类
static MeterFilter renameTag(String metricPrefix, String fromTagKey, String toTagKey) {
    return new MeterFilter() {
        @Override
        public Meter.Id map(Meter.Id id) {
            if (!id.getName().startsWith(metricPrefix))
                return id;

            List<Tag> tags = new ArrayList<>();
            for (Tag tag : id.getTags()) {
                if (tag.getKey().equals(fromTagKey))
                    tags.add(Tag.of(toTagKey, tag.getValue()));
                else tags.add(tag);
            }

            return new Meter.Id(id.getName(), tags, id.getBaseUnit(), id.getDescription(), id.getType());
        }
    };
}
 

import io.micrometer.core.instrument.Meter; //导入依赖的package包/类
static MeterFilter ignoreTags(String... tagKeys) {
    return new MeterFilter() {
        @Override
        public Meter.Id map(Meter.Id id) {
            List<Tag> tags = stream(id.getTags().spliterator(), false)
                .filter(t -> {
                    for (String tagKey : tagKeys) {
                        if (t.getKey().equals(tagKey))
                            return false;
                    }
                    return true;
                }).collect(Collectors.toList());

            return new Meter.Id(id.getName(), tags, id.getBaseUnit(), id.getDescription(), id.getType());
        }
    };
}
 

import io.micrometer.core.instrument.Meter; //导入依赖的package包/类
/**
 * @param tagKey      The tag key for which replacements should be made
 * @param replacement The value to replace with
 * @param exceptions  All a matching tag with this value to retain its original value
 * @author Clint Checketts
 */
static MeterFilter replaceTagValues(String tagKey, Function<String, String> replacement, String... exceptions) {
    return new MeterFilter() {
        @Override
        public Meter.Id map(Meter.Id id) {
            List<Tag> tags = stream(id.getTags().spliterator(), false)
                .map(t -> {
                    if (!t.getKey().equals(tagKey))
                        return t;
                    for (String exception : exceptions) {
                        if (t.getValue().equals(exception))
                            return t;
                    }
                    return Tag.of(tagKey, replacement.apply(t.getValue()));
                })
                .collect(Collectors.toList());

            return new Meter.Id(id.getName(), tags, id.getBaseUnit(), id.getDescription(), id.getType());
        }
    };
}
 

import io.micrometer.core.instrument.Meter; //导入依赖的package包/类
StatsdLineBuilder(Meter.Id id, StatsdFlavor flavor, HierarchicalNameMapper nameMapper, MeterRegistry.Config config) {
    this.id = id;
    this.flavor = flavor;
    this.nameMapper = nameMapper;
    this.config = config;

    // service:payroll,region:us-west
    this.datadogTagString = memoize(convention ->
        id.getTags().iterator().hasNext() ?
            id.getConventionTags(convention).stream()
                .map(t -> t.getKey() + ":" + t.getValue())
                .collect(Collectors.joining(","))
            : null
    );

    // service=payroll,region=us-west
    this.telegrafTagString = memoize(convention ->
        id.getTags().iterator().hasNext() ?
            id.getConventionTags(convention).stream()
                .map(t -> t.getKey() + "=" + t.getValue())
                .collect(Collectors.joining(","))
            : null
    );
}
 

import io.micrometer.core.instrument.Meter; //导入依赖的package包/类
@Override
public String toHierarchicalName(Meter.Id id, NamingConvention convention) {
    StringBuilder prefix = new StringBuilder();
    StringBuilder tags = new StringBuilder();

    if (id.getTags().iterator().hasNext()) {
        conventionTags: for (Tag tag : id.getConventionTags(convention)) {
            for (String tagPrefix : tagsAsPrefix) {
                if (tag.getKey().equals(tagPrefix)) {
                    prefix.append(tag.getValue()).append(".");
                    continue conventionTags;
                }
            }

            tags.append(("." + tag.getKey() + "." + tag.getValue()).replace(" ", "_"));
        }
    }

    return prefix.toString() + id.getConventionName(convention) + tags;
}
 

import io.micrometer.core.instrument.Meter; //导入依赖的package包/类
private static String measurementName(Meter.Id id, Measurement measurement) {
    final StringBuilder buf = new StringBuilder();

    // Append name.
    buf.append(id.getName());

    // Append statistic.
    buf.append('#');
    buf.append(CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, measurement.getStatistic().name()));

    // Append tags if there are any.
    final Iterator<Tag> tagsIterator = id.getTags().iterator();
    if (tagsIterator.hasNext()) {
        buf.append('{');
        tagsIterator.forEachRemaining(tag -> buf.append(tag.getKey()).append('=')
                                                .append(tag.getValue()).append(','));
        buf.setCharAt(buf.length() - 1, '}');
    }
    return buf.toString();
}
 

import io.micrometer.core.instrument.Meter; //导入依赖的package包/类
CompositeFunctionTimer(Meter.Id id, T obj, ToLongFunction<T> countFunction,
                       ToDoubleFunction<T> totalTimeFunction, TimeUnit totalTimeFunctionUnits) {
    super(id);
    this.ref = new WeakReference<>(obj);
    this.countFunction = countFunction;
    this.totalTimeFunction = totalTimeFunction;
    this.totalTimeFunctionUnits = totalTimeFunctionUnits;
}
 

import io.micrometer.core.instrument.Meter; //导入依赖的package包/类
@Override
public void add(MeterRegistry registry) {
    Meter.builder(getId().getName(), getType(), measure())
        .tags(getId().getTags())
        .description(getId().getDescription())
        .baseUnit(getId().getBaseUnit())
        .register(registry);
}
 

import io.micrometer.core.instrument.Meter; //导入依赖的package包/类
static MeterFilter commonTags(Iterable<Tag> tags) {
    return new MeterFilter() {
        @Override
        public Meter.Id map(Meter.Id id) {
            List<Tag> allTags = new ArrayList<>();
            id.getTags().forEach(allTags::add);
            tags.forEach(allTags::add);
            return new Meter.Id(id.getName(), allTags, id.getBaseUnit(), id.getDescription(), id.getType());
        }
    };
}
 

import io.micrometer.core.instrument.Meter; //导入依赖的package包/类
static MeterFilter accept(Predicate<Meter.Id> iff) {
    return new MeterFilter() {
        @Override
        public MeterFilterReply accept(Meter.Id id) {
            return iff.test(id) ? MeterFilterReply.ACCEPT : MeterFilterReply.NEUTRAL;
        }
    };
}
 

import io.micrometer.core.instrument.Meter; //导入依赖的package包/类
static MeterFilter deny(Predicate<Meter.Id> iff) {
    return new MeterFilter() {
        @Override
        public MeterFilterReply accept(Meter.Id id) {
            return iff.test(id) ? MeterFilterReply.DENY : MeterFilterReply.NEUTRAL;
        }
    };
}
 

import io.micrometer.core.instrument.Meter; //导入依赖的package包/类
/**
 * Useful for cost-control in monitoring systems which charge directly or indirectly by the
 * total number of time series you generate.
 * <p>
 * While this filter doesn't discriminate between your most critical and less useful metrics in
 * deciding what to drop (all the metrics you intend to use should fit below this threshold),
 * it can effectively cap your risk of an accidentally high-cardiality metric costing too much.
 *
 * @param maximumTimeSeries The total number of unique name/tag permutations allowed before filtering kicks in.
 */
static MeterFilter maximumAllowableMetrics(int maximumTimeSeries) {
    return new MeterFilter() {
        private final Set<Meter.Id> ids = ConcurrentHashMap.newKeySet();

        @Override
        public MeterFilterReply accept(Meter.Id id) {
            if (ids.size() > maximumTimeSeries)
                return MeterFilterReply.DENY;

            ids.add(id);
            return ids.size() > maximumTimeSeries ? MeterFilterReply.DENY : MeterFilterReply.NEUTRAL;
        }
    };
}
 

import io.micrometer.core.instrument.Meter; //导入依赖的package包/类
@Override
public MeterFilterReply accept(Meter.Id id) {
    Boolean enabled = getMostSpecific(id.getName(), "enabled", Boolean.class);
    if(enabled == null)
        return MeterFilterReply.NEUTRAL;
    return enabled ? MeterFilterReply.ACCEPT : MeterFilterReply.DENY;
}
 

import io.micrometer.core.instrument.Meter; //导入依赖的package包/类
public static boolean equals(Meter m1, Object o) {
    if (m1 == null && o != null) return false;
    if (o == null && m1 != null) return false;
    if (!(o instanceof Meter)) return false;
    if (m1 == o) return true;
    Meter m2 = (Meter) o;
    return m1.getId().equals(m2.getId());
}
 

import io.micrometer.core.instrument.Meter; //导入依赖的package包/类
@Test
void customMeasurementsThatDifferOnlyInTagValue() {
    Meter.builder("my.custom", Meter.Type.Gauge, Arrays.asList(
        new Measurement(() -> 1.0, Statistic.Count),
        new Measurement(() -> 2.0, Statistic.Total)
    )).register(registry);
}
 

import io.micrometer.core.instrument.Meter; //导入依赖的package包/类
@Test
@DisplayName("function-tracking counter increments by change in a monotonically increasing function when observed")
default void functionTrackingCounter(MeterRegistry registry) {
    AtomicLong n = new AtomicLong(0);
    registry.more().counter("tracking", emptyList(), n);
    n.incrementAndGet();

    clock(registry).add(step());
    registry.forEachMeter(Meter::measure);
    assertThat(registry.mustFind("tracking").functionCounter().count()).isEqualTo(1.0);
}
 

import io.micrometer.core.instrument.Meter; //导入依赖的package包/类
StatsdDistributionSummary(Meter.Id id, StatsdLineBuilder lineBuilder, Subscriber<String> publisher, Clock clock,
                          HistogramConfig histogramConfig, long stepMillis) {
    super(id, clock, histogramConfig);
    this.max = new TimeDecayingMax(clock, histogramConfig);
    this.lineBuilder = lineBuilder;
    this.publisher = publisher;
}
 

import io.micrometer.core.instrument.Meter; //导入依赖的package包/类
StatsdGauge(Meter.Id id, StatsdLineBuilder lineBuilder, Subscriber<String> publisher, T obj, ToDoubleFunction<T> value) {
    super(id);
    this.lineBuilder = lineBuilder;
    this.publisher = publisher;
    this.ref = new WeakReference<>(obj);
    this.value = value;
}
 

import io.micrometer.core.instrument.Meter; //导入依赖的package包/类
public MicrometerCollector(Meter.Id id, Type type, NamingConvention convention, PrometheusConfig config) {
    this.id = id;
    this.type = type;
    this.conventionName = id.getConventionName(convention);
    this.tagKeys = id.getConventionTags(convention).stream().map(Tag::getKey).collect(toList());
    this.config = config;
}
 

import io.micrometer.core.instrument.Meter; //导入依赖的package包/类
DatadogMetricMetadata(Meter.Id id, Statistic statistic, boolean descriptionsEnabled, String overrideBaseUnit) {
    this.id = id;
    this.descriptionsEnabled = descriptionsEnabled;
    this.overrideBaseUnit = overrideBaseUnit;

    switch (statistic) {
        case Count:
        case Total:
        case TotalTime:
            this.type = "count";
            break;
        default:
            this.type = "gauge";
    }
}