io.micrometer.core.lang.Nullable Java Examples

public static InfluxMeterRegistry influx() {
    return new InfluxMeterRegistry(new InfluxConfig() {
        @Override
        public String userName() {
            return "admin";
        }

        @Override
        public String password() {
            return "admin";
        }

        @Override
        public Duration step() {
            return Duration.ofSeconds(10);
        }

        @Override
        @Nullable
        public String get(String k) {
            return null;
        }
    }, Clock.SYSTEM);
}
 

@Nullable
static com.netflix.spectator.api.Statistic toSpectatorStatistic(Statistic stat) {
    switch (stat) {
        case COUNT:
            return count;
        case TOTAL_TIME:
            return totalTime;
        case TOTAL:
            return totalAmount;
        case VALUE:
            return gauge;
        case ACTIVE_TASKS:
            return activeTasks;
        case DURATION:
            return duration;
        case MAX:
            return max;
    }
    return null;
}
 

/**
 * Creates a {@code uri} tag based on the URI of the given {@code request}. Uses the
 * {@link HandlerMapping#BEST_MATCHING_PATTERN_ATTRIBUTE} best matching pattern if
 * available. Falling back to {@code REDIRECTION} for 3xx responses, {@code NOT_FOUND}
 * for 404 responses, {@code root} for requests with no path info, and {@code UNKNOWN}
 * for all other requests.
 *
 * @param request the request
 * @param response the response
 * @return the uri tag derived from the request
 */
public static Tag uri(@Nullable HttpServletRequest request, @Nullable HttpServletResponse response) {
    if (request != null) {
        String pattern = getMatchingPattern(request);
        if (pattern != null) {
            return Tag.of("uri", pattern);
        } else if (response != null) {
            HttpStatus status = extractStatus(response);
            if (status != null && status.is3xxRedirection()) {
                return URI_REDIRECTION;
            }
            if (status != null && status.equals(HttpStatus.NOT_FOUND)) {
                return URI_NOT_FOUND;
            }
        }
        String pathInfo = getPathInfo(request);
        if (pathInfo.isEmpty()) {
            return URI_ROOT;
        }
    }
    return URI_UNKNOWN;
}
 

public static StatsdMeterRegistry datadogStatsd() {
    return new StatsdMeterRegistry(new StatsdConfig() {
        @Override
        public Duration step() {
            return Duration.ofSeconds(10);
        }

        @Override
        @Nullable
        public String get(String k) {
            return null;
        }

        @Override
        public StatsdFlavor flavor() {
            return StatsdFlavor.DATADOG;
        }
    }, Clock.SYSTEM);
}
 

@Override
public MeterRegistry registry() {
    return new InfluxMeterRegistry(new InfluxConfig() {
        @Override
        public boolean enabled() {
            return false;
        }

        @Override
        @Nullable
        public String get(String key) {
            return null;
        }
    }, new MockClock());
}
 

/**
 * @param count            Total number of recordings
 * @param total            In nanos if a unit of time
 * @param max              In nanos if a unit of time
 * @param percentileValues Pre-computed percentiles.
 * @param histogramCounts  Bucket counts.
 * @param summaryOutput    A function defining how to print the histogram.
 */
public HistogramSnapshot(long count, double total, double max,
                         @Nullable ValueAtPercentile[] percentileValues,
                         @Nullable CountAtBucket[] histogramCounts,
                         @Nullable BiConsumer<PrintStream, Double> summaryOutput) {
    this.count = count;
    this.total = total;
    this.max = max;
    this.percentileValues = percentileValues != null ? percentileValues : EMPTY_VALUES;
    this.histogramCounts = histogramCounts != null ? histogramCounts : EMPTY_COUNTS;
    this.summaryOutput = summaryOutput;
}
 

public static AtlasMeterRegistry atlas() {
    return new AtlasMeterRegistry(new AtlasConfig() {
        @Override
        public Duration step() {
            return Duration.ofSeconds(10);
        }

        @SuppressWarnings("ConstantConditions")
        @Override
        @Nullable
        public String get(String k) {
            return null;
        }
    }, Clock.SYSTEM);
}
 

/**
 * @param key The tag key to attempt to match.
 * @return A matching tag value, or {@code null} if no tag with the provided key exists on this id.
 */
@Nullable
public String getTag(String key) {
    for (Tag tag : tags) {
        if (tag.getKey().equals(key))
            return tag.getValue();
    }
    return null;
}
 

@Nullable
private Method detectMethod(String name) {
    requireNonNull(name);
    if (operatingSystemBeanClass == null) {
        return null;
    }
    try {
        // ensure the Bean we have is actually an instance of the interface
        operatingSystemBeanClass.cast(operatingSystemBean);
        return operatingSystemBeanClass.getDeclaredMethod(name);
    } catch (ClassCastException | NoSuchMethodException | SecurityException e) {
        return null;
    }
}
 

@Override
public boolean equals(@Nullable Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Tag that = (Tag) o;
    return Objects.equals(key, that.getKey()) &&
        Objects.equals(value, that.getValue());
}
 

@Override
protected <T> io.micrometer.core.instrument.Gauge newGauge(Meter.Id id, @Nullable T obj, ToDoubleFunction<T> valueFunction) {
    Gauge gauge = new DefaultGauge<>(id, obj, valueFunction);
    applyToCollector(id, (collector) -> {
        List<String> tagValues = tagValues(id);
        collector.add(tagValues, (conventionName, tagKeys) -> Stream.of(new MicrometerCollector.Family(Collector.Type.GAUGE, conventionName,
                new Collector.MetricFamilySamples.Sample(conventionName, tagKeys, tagValues, gauge.value()))));
    });
    return gauge;
}
 

StatsdGauge(Id id, StatsdLineBuilder lineBuilder, FluxSink<String> sink, @Nullable T obj, ToDoubleFunction<T> value, boolean alwaysPublish) {
    super(id);
    this.lineBuilder = lineBuilder;
    this.sink = sink;
    this.ref = new WeakReference<>(obj);
    this.value = value;
    this.alwaysPublish = alwaysPublish;
}
 

/**
 * Supplies default tags to the Web MVC server programming model.
 *
 * @param request  The HTTP request.
 * @param response The HTTP response.
 * @param ex       The current exception, if any
 * @return A set of tags added to every Spring MVC HTTP request.
 */
@Override
public Iterable<Tag> httpRequestTags(@Nullable HttpServletRequest request,
                                     @Nullable HttpServletResponse response,
                                     @Nullable Object handler,
                                     @Nullable Throwable ex) {
    return Arrays.asList(WebMvcTags.method(request), WebMvcTags.uri(request, response),
        WebMvcTags.exception(ex), WebMvcTags.status(response));
}
 

@Nullable
private Method detectMethod(String name) {
    if (osBeanClass == null) {
        return null;
    }
    try {
        // ensure the Bean we have is actually an instance of the interface
        osBeanClass.cast(osBean);
        return osBeanClass.getDeclaredMethod(name);
    } catch (ClassCastException | NoSuchMethodException | SecurityException e) {
        return null;
    }
}
 

/**
 * @param mappedId The id of the meter to remove
 * @return The removed meter, or null if no meter matched the provided id.
 * @since 1.1.0
 */
@Incubating(since = "1.1.0")
@Nullable
public Meter remove(Meter.Id mappedId) {
    Meter m = meterMap.get(mappedId);

    if (m != null) {
        synchronized (meterMapLock) {
            m = meterMap.remove(mappedId);
            if (m != null) {
                Set<Id> synthetics = syntheticAssociations.remove(mappedId);
                if (synthetics != null) {
                    for (Id synthetic : synthetics) {
                        remove(synthetic);
                    }
                }

                for (Consumer<Meter> onRemove : meterRemovedListeners) {
                    onRemove.accept(m);
                }

                return m;
            }
        }
    }

    return null;
}
 

@Override
public MeterRegistry registry() {
    return GangliaMeterRegistry.builder(new GangliaConfig() {
        @Override
        public boolean enabled() {
            return false;
        }

        @Override
        @Nullable
        public String get(String key) {
            return null;
        }
    }).clock(new MockClock()).build();
}
 

private static StatsdConfig configWithFlavor(StatsdFlavor flavor) {
    return new StatsdConfig() {
        @Override
        @Nullable
        public String get(String key) {
            return null;
        }

        @Override
        public StatsdFlavor flavor() {
            return flavor;
        }
    };
}
 

@Nullable
private static HttpStatus extractStatus(HttpServletResponse response) {
    try {
        if (response instanceof MetricsServletResponse) {
            return HttpStatus.valueOf(((MetricsServletResponse)response).getStatus());
        }
        else {
            return HttpStatus.OK;
        }
    } catch (IllegalArgumentException ex) {
        return null;
    }
}
 

private <M extends Meter> M registerMeterIfNecessary(Class<M> meterClass, Meter.Id id,
                                                     @Nullable DistributionStatisticConfig config, BiFunction<Meter.Id, DistributionStatisticConfig, M> builder,
                                                     Function<Meter.Id, M> noopBuilder) {
    Id mappedId = getMappedId(id);
    Meter m = getOrCreateMeter(config, builder, id, mappedId, noopBuilder);

    if (!meterClass.isInstance(m)) {
        throw new IllegalArgumentException("There is already a registered meter of a different type with the same name");
    }
    return meterClass.cast(m);
}
 

@Override
public MeterRegistry registry() {
    return new KairosMeterRegistry(new KairosConfig() {
        @Override
        public boolean enabled() {
            return false;
        }

        @Override
        @Nullable
        public String get(String key) {
            return null;
        }
    }, new MockClock());
}
 

/**
 * Supplies default tags to the Web MVC server programming model.
 *
 * @param request  The HTTP request.
 * @param response The HTTP response.
 * @param ex       The current exception, if any
 * @return A set of tags added to every Spring MVC HTTP request.
 */
@Override
public Iterable<Tag> httpRequestTags(@Nullable HttpServletRequest request,
                                     @Nullable HttpServletResponse response,
                                     @Nullable Object handler,
                                     @Nullable Throwable ex) {
    return Arrays.asList(WebMvcTags.method(request), WebMvcTags.uri(request, response),
        WebMvcTags.exception(ex), WebMvcTags.status(response));
}
 

public static String escapeJson(@Nullable String v) {
    if (v == null) return "";
    int length = v.length();
    if (length == 0) return v;

    int afterReplacement = 0;
    StringBuilder builder = null;
    for (int i = 0; i < length; i++) {
        char c = v.charAt(i);
        String replacement;
        if (c < 0x80) {
            replacement = REPLACEMENT_CHARS[c];
            if (replacement == null) continue;
        } else if (c == '\u2028') {
            replacement = U2028;
        } else if (c == '\u2029') {
            replacement = U2029;
        } else {
            continue;
        }
        if (afterReplacement < i) { // write characters between the last replacement and now
            if (builder == null) builder = new StringBuilder(length);
            builder.append(v, afterReplacement, i);
        }
        if (builder == null) builder = new StringBuilder(length);
        builder.append(replacement);
        afterReplacement = i + 1;
    }
    if (builder == null) return v; // then we didn't escape anything

    if (afterReplacement < length) {
        builder.append(v, afterReplacement, length);
    }
    return builder.toString();
}
 

/**
 * Unwrap the {@link SessionFactory} from {@link EntityManagerFactory}.
 *
 * @param entityManagerFactory {@link EntityManagerFactory} to unwrap
 * @return unwrapped {@link SessionFactory}
 */
@Nullable
private SessionFactory unwrap(EntityManagerFactory entityManagerFactory) {
    try {
        return entityManagerFactory.unwrap(SessionFactory.class);
    } catch (PersistenceException ex) {
        return null;
    }
}
 

/**
 * Check if the String is null or has only whitespaces.
 *
 * Modified from {@link org.apache.commons.lang.StringUtils#isBlank(String)}.
 *
 * @param string String to check
 * @return {@code true} if the String is null or has only whitespaces
 */
public static boolean isBlank(@Nullable String string) {
    if (isEmpty(string)) {
        return true;
    }
    for (int i = 0; i < string.length(); i++) {
        if (!Character.isWhitespace(string.charAt(i))) {
            return false;
        }
    }
    return true;
}
 

@Nullable
private String nameDetail() {
    if (search.nameMatches == null)
        return null;

    Collection<String> matchingName = Search.in(search.registry)
            .name(search.nameMatches)
            .meters()
            .stream()
            .map(m -> m.getId().getName())
            .distinct()
            .sorted()
            .collect(toList());

    if (!matchingName.isEmpty()) {
        if (matchingName.size() == 1) {
            return OK + " A meter with name '" + matchingName.iterator().next() + "' was found.";
        } else {
            return OK + " Meters with names ["
                    + matchingName.stream().map(name -> "'" + name + "'").collect(joining(", "))
                    + "] were found.";
        }
    }

    if (search.exactNameMatch != null) {
        return NOT_OK + " No meter with name '" + search.exactNameMatch + "' was found.";
    }
    return NOT_OK + " No meter that matches the name predicate was found.";
}
 

private Tags generateTagsForRoute(@Nullable Request request) {
    if (request == null) {
        return TAGS_TARGET_UNKNOWN;
    }
    return Tags.of(
            TAG_TARGET_SCHEME, request.url().scheme(),
            TAG_TARGET_HOST, request.url().host(),
            TAG_TARGET_PORT, Integer.toString(request.url().port())
    );
}
 

@Nullable
@Override
public String get(String key) {
    Element element = cache.get(key);
    return element == null ? null : (String) element.getObjectValue();
}
 

/**
 * Protocol version.
 * @return protocol version
 * @deprecated since 1.5.0
 */
@Deprecated
@Nullable
default String protocolVersion() {
    return null;
}
 

/**
 * @return The tag that will be mapped to {@literal @host} when shipping metrics to AppOptics.
 */
@Nullable
default String hostTag() {
    return getString(this, "hostTag").orElse("instance");
}
 

private MeterNotFoundException(@Nullable String nameDetail, @Nullable String typeDetail, @Nullable List<String> tagDetail) {
    super("Unable to find a meter that matches all the requirements at once. Here's what was found:"
            + (nameDetail == null ? "" : "\n   " + nameDetail)
            + (typeDetail == null ? "" : "\n   " + typeDetail)
            + (tagDetail == null ? "" : "\n   " + tagDetail.stream().collect(joining("\n   "))));
}