App.Metrics by Allan Hardy

<PackageReference Include="App.Metrics" Version="1.0.0-beta5-2" />

---

API Diff between 1.0.0-beta5-2 and 4.0.0

1124 Additions 1 Removals

App.Metrics

• public static class AppMetrics
• public static class HealthCheckFactoryExtensions
  • public static IHealthCheckFactory RegisterProcessPhysicalMemoryHealthCheck(this IHealthCheckFactory factory, string name, long thresholdBytes)
  • public static IHealthCheckFactory RegisterProcessPrivateMemorySizeHealthCheck(this IHealthCheckFactory factory, string name, long thresholdBytes)
  • public static IHealthCheckFactory RegisterProcessVirtualMemorySizeHealthCheck(this IHealthCheckFactory factory, string name, long thresholdBytes)
• public interface IClock
  • long Nanoseconds { get; }
  • long Seconds { get; }
  • DateTime UtcDateTime { get; }
  • event EventHandler Advanced
  • void Advance(TimeUnit unit, long value)
  • string FormatTimestamp(DateTime timestamp)
• public interface IMetrics
  • IBuildMetrics Build { get; }
  • IClock Clock { get; }
  • IFilterMetrics GlobalFilter { get; }
  • IProvideHealth Health { get; }
  • IManageMetrics Manage { get; }
  • IMeasureMetrics Measure { get; }
  • IProvideMetrics Provider { get; }
  • IProvideMetricValues Snapshot { get; }
• public enum MetricType
  • Apdex = 5
  • Counter = 1
  • Gauge = 0
  • Histogram = 3
  • Meter = 2
  • Timer = 4
• public enum TimeUnit
  • Days = 6
  • Hours = 5
  • Microseconds = 1
  • Milliseconds = 2
  • Minutes = 4
  • Nanoseconds = 0
  • Seconds = 3
• public static class TimeUnitExtensions
  • public static long Convert(this TimeUnit sourceUnit, TimeUnit targetUnit, long value)
  • public static TimeUnit FromUnit(this string unit)
  • public static double ScalingFactorFor(this TimeUnit sourceUnit, TimeUnit targetUnit)
  • public static long ToDays(this TimeUnit unit, long value)
  • public static long ToHours(this TimeUnit unit, long value)
  • public static long ToMicroseconds(this TimeUnit unit, long value)
  • public static long ToMilliseconds(this TimeUnit unit, long value)
  • public static long ToMinutes(this TimeUnit unit, long value)
  • public static long ToNanoseconds(this TimeUnit unit, long value)
  • public static long ToSeconds(this TimeUnit unit, long value)
  • public static string Unit(this TimeUnit unit)
• public struct Unit
  • public static readonly Unit Bytes
  • public static readonly Unit Calls
  • public static readonly Unit Commands
  • public static readonly Unit Errors
  • public static readonly Unit Events
  • public static readonly Unit Items
  • public static readonly Unit KiloBytes
  • public static readonly Unit MegaBytes
  • public static readonly Unit None
  • public static readonly Unit Percent
  • public static readonly Unit Requests
  • public static readonly Unit Results
  • public static readonly Unit Threads
  • public string Name { get; }
  • public static Unit Custom(string name)
  • public static bool op_Equality(Unit left, Unit right)
  • public static Unit op_Implicit(string name)
  • public static bool op_Inequality(Unit left, Unit right)
  • public bool Equals(Unit other)
  • public string FormatCount(long value)
  • public string FormatDuration(double value, TimeUnit? timeUnit)
  • public string FormatRate(double value, TimeUnit timeUnit)
  • public string FormatValue(double value)

App.Metrics.Abstractions.Filtering

• public interface IFilterMetrics
  • bool ReportEnvironment { get; }
  • bool ReportHealthChecks { get; }
  • bool IsApdexMatch(ApdexValueSource apdex)
  • bool IsContextMatch(string context)
  • bool IsCounterMatch(CounterValueSource counter)
  • bool IsGaugeMatch(GaugeValueSource gauge)
  • bool IsHistogramMatch(HistogramValueSource histogram)
  • bool IsMeterMatch(MeterValueSource meter)
  • bool IsTimerMatch(TimerValueSource timer)
  • IFilterMetrics WhereContext(Predicate<string> condition)
  • IFilterMetrics WhereContext(string context)
  • IFilterMetrics WhereMetricName(Predicate<string> condition)
  • IFilterMetrics WhereMetricNameStartsWith(string name)
  • IFilterMetrics WhereMetricTaggedWithKey(string[] tagKeys)
  • IFilterMetrics WhereMetricTaggedWithKeyValue(TagKeyValueFilter tags)
  • IFilterMetrics WhereType(MetricType[] types)
  • IFilterMetrics WithEnvironmentInfo(bool report)
  • IFilterMetrics WithHealthChecks(bool report)

App.Metrics.Abstractions.MetricTypes

• public interface ICounterMetric : ICounter, IResetableMetric, IMetricValueProvider<CounterValue>
• public interface IGaugeMetric : IMetricValueProvider<double>
• public interface IHistogramMetric : IHistogram, IResetableMetric, IMetricValueProvider<HistogramValue>, IDisposable
• public interface IMeterMetric : IMeter, IResetableMetric, IMetricValueProvider<MeterValue>, IDisposable
• public interface ITimerMetric : ITimer, IResetableMetric, IMetricValueProvider<TimerValue>

App.Metrics.Abstractions.Metrics

• public interface IApdexMetric : IApdex, IResetableMetric, IMetricValueProvider<ApdexValue>, IDisposable

App.Metrics.Abstractions.Reporting

• public interface IMetricReporter : IHideObjectMembers, IDisposable
  • string Name { get; }
  • TimeSpan ReportInterval { get; }
  • Task<bool> EndAndFlushReportRunAsync(IMetrics metrics)
  • void ReportEnvironment(EnvironmentInfo environmentInfo)
  • void ReportHealth(GlobalMetricTags globalTags, IEnumerable<Result> healthyChecks, IEnumerable<Result> degradedChecks, IEnumerable<Result> unhealthyChecks)
  • void ReportMetric<T>(string context, MetricValueSourceBase<T> valueSource)
  • void StartReportRun(IMetrics metrics)
• public interface IReporterProvider
  • IFilterMetrics Filter { get; }
  • IMetricReporter CreateMetricReporter(string name, ILoggerFactory loggerFactory)
• public interface IReporterSettings
  • TimeSpan ReportInterval { get; }

App.Metrics.Abstractions.ReservoirSampling

• public interface IReservoir
  • IReservoirSnapshot GetSnapshot(bool resetReservoir)
  • IReservoirSnapshot GetSnapshot()
  • void Reset()
  • void Update(long value, string userValue)
  • void Update(long value)
• public interface IReservoirSnapshot
  • long Count { get; }
  • long Max { get; }
  • string MaxUserValue { get; }
  • double Mean { get; }
  • double Median { get; }
  • long Min { get; }
  • string MinUserValue { get; }
  • double Percentile75 { get; }
  • double Percentile95 { get; }
  • double Percentile98 { get; }
  • double Percentile99 { get; }
  • double Percentile999 { get; }
  • int Size { get; }
  • double StdDev { get; }
  • IEnumerable<long> Values { get; }
  • double GetValue(double quantile)

App.Metrics.Abstractions.Serialization

• public interface IHealthStatusSerializer
  • T Deserialize<T>(string json)
  • string Serialize<T>(T value)
• public interface IMetricDataSerializer
  • T Deserialize<T>(string json)
  • string Serialize<T>(T value)

App.Metrics.Apdex

• public struct ApdexContext : IDisposable
  • public TimeSpan Elapsed { get; }
  • public ApdexContext(IApdex apdex)
  • public void Dispose()
• public sealed class ApdexMetric : MetricBase
  • public int Frustrating { get; set; }
  • public int SampleSize { get; set; }
  • public int Satisfied { get; set; }
  • public double Score { get; set; }
  • public int Tolerating { get; set; }
  • public ApdexMetric()
• public class ApdexProvider : IApdexProvider, IDisposable
  • public ApdexProvider(Lazy<IReservoir> reservoir)
  • public ApdexProvider(Lazy<IReservoir> reservoir, double apdexTSeconds)
  • public void Dispose()
  • public void Dispose(bool disposing)
  • public ApdexSnapshot GetSnapshot(bool resetReservoir = false)
  • public void Reset()
  • public void Update(long value)
• public struct ApdexSnapshot
  • public int FrustratingSize { get; }
  • public int SatisfiedSize { get; }
  • public int ToleratingSize { get; }
  • public ApdexSnapshot(IEnumerable<long> samples, double apdexTSeconds)
  • public static bool op_Equality(ApdexSnapshot left, ApdexSnapshot right)
  • public static bool op_Inequality(ApdexSnapshot left, ApdexSnapshot right)
  • public bool Equals(ApdexSnapshot other)
• public sealed class ApdexValue
  • public int Frustrating { get; }
  • public int SampleSize { get; }
  • public int Satisfied { get; }
  • public double Score { get; }
  • public int Tolerating { get; }
  • public ApdexValue(double score, int satisfied, int tolerating, int frustrating, int sampleSize, bool allowWarmup = true)
• public sealed class ApdexValueSource : MetricValueSourceBase<ApdexValue>
  • public bool ResetOnReporting { get; }
  • public ApdexValueSource(string name, IMetricValueProvider<ApdexValue> value, MetricTags tags, bool resetOnReporting = false)
• public static class ApdexValueSourceExtensions
  • public static ApdexValue GetApdexValue(this IProvideMetricValues valueService, string context, string metricName)
  • public static ApdexValue GetValueOrDefault(this IApdex metric)
  • public static IEnumerable<ApdexMetric> ToMetric(this IEnumerable<ApdexValueSource> source)
  • public static ApdexMetric ToMetric(this ApdexValueSource source)
  • public static ApdexValueSource ToMetricValueSource(this ApdexMetric source)
  • public static IEnumerable<ApdexValueSource> ToMetricValueSource(this IEnumerable<ApdexMetric> source)
• public class DefaultApdexBuilder : IBuildApdexMetrics
  • public DefaultApdexBuilder(DefaultSamplingReservoirProvider defaultSamplingReservoirProvider)
  • public IApdexMetric Build(double apdexTSeconds, bool allowWarmup, IClock clock)
  • public IApdexMetric Build(Lazy<IReservoir> reservoir, double apdexTSeconds, bool allowWarmup, IClock clock)
• public sealed class DefaultApdexMetric : IApdexMetric, IApdex, IResetableMetric, IMetricValueProvider<ApdexValue>, IDisposable
  • public ApdexValue Value { get; }
  • public DefaultApdexMetric(Lazy<IReservoir> reservoir, double apdexTSeconds, IClock clock, bool allowWarmup)
  • public DefaultApdexMetric(Lazy<IReservoir> reservoir, IClock clock, bool allowWarmup)
  • public DefaultApdexMetric(IApdexProvider apdexProvider, IClock clock, bool allowWarmup)
  • public long CurrentTime()
  • public void Dispose()
  • public void Dispose(bool disposing)
  • public long EndRecording()
  • public ApdexValue GetValue(bool resetMetric = false)
  • public ApdexContext NewContext()
  • public void Reset()
  • public long StartRecording()
  • public void Track(long duration)
  • public void Track(Action action)
  • public T Track<T>(Func<T> action)
• public class DefaultApdexMetricProvider : IProvideApdexMetrics
  • public DefaultApdexMetricProvider(IBuildApdexMetrics apdexBuidler, IMetricsRegistry registry, IClock clock)
  • public IApdex Instance(ApdexOptions options)
  • public IApdex Instance<T>(ApdexOptions options, Func<T> builder) where T : IApdexMetric

App.Metrics.Apdex.Abstractions

• public interface IApdex : IResetableMetric
  • long CurrentTime()
  • long EndRecording()
  • ApdexContext NewContext()
  • long StartRecording()
  • void Track(long duration)
  • void Track(Action action)
  • T Track<T>(Func<T> action)
• public interface IApdexProvider : IDisposable
  • ApdexSnapshot GetSnapshot(bool resetReservoir = false)
  • void Reset()
  • void Update(long value)
• public interface IBuildApdexMetrics
  • IApdexMetric Build(double apdexTSeconds, bool allowWarmup, IClock clock)
  • IApdexMetric Build(Lazy<IReservoir> reservoir, double apdexTSeconds, bool allowWarmup, IClock clock)
• public interface IMeasureApdexMetrics
  • void Track(ApdexOptions options, Action action)
  • ApdexContext Track(ApdexOptions options)
• public interface IProvideApdexMetrics
  • IApdex Instance(ApdexOptions options)
  • IApdex Instance<T>(ApdexOptions options, Func<T> builder) where T : IApdexMetric

App.Metrics.Configuration

• public static class AppMetricsOptionExtensions
  • public static AppMetricsOptions WithGlobalTags(this AppMetricsOptions options, Action<Dictionary<string, string>, EnvironmentInfo> setupAction)
• public sealed class AppMetricsOptions
  • public string DefaultContextLabel { get; set; }
  • public GlobalMetricTags GlobalTags { get; set; }
  • public bool MetricsEnabled { get; set; }
  • public bool ReportingEnabled { get; set; }
  • public AppMetricsOptions()

App.Metrics.Core

• public static class ConstantValue
  • public static IMetricValueProvider<T> Provider<T>(T value)
• public static class HumannizeHealthCheckStatus
  • public static string Hummanize(this HealthCheckStatus status)
• public sealed class MetricData
  • public IEnumerable<MetricsContext> Contexts { get; set; }
  • public IDictionary<string, string> Environment { get; set; }
  • public DateTime Timestamp { get; set; }
  • public MetricData()
• public sealed class MetricsContext
  • public IEnumerable<ApdexMetric> ApdexScores { get; set; }
  • public string Context { get; set; }
  • public IEnumerable<CounterMetric> Counters { get; set; }
  • public IEnumerable<GaugeMetric> Gauges { get; set; }
  • public IEnumerable<HistogramMetric> Histograms { get; set; }
  • public IEnumerable<MeterMetric> Meters { get; set; }
  • public IEnumerable<TimerMetric> Timers { get; set; }
  • public MetricsContext()
• public sealed class MetricsContextValueSource
  • public static readonly MetricsContextValueSource Empty
  • public IEnumerable<ApdexValueSource> ApdexScores { get; }
  • public string Context { get; }
  • public IEnumerable<CounterValueSource> Counters { get; }
  • public IEnumerable<GaugeValueSource> Gauges { get; }
  • public IEnumerable<HistogramValueSource> Histograms { get; }
  • public IEnumerable<MeterValueSource> Meters { get; }
  • public IEnumerable<TimerValueSource> Timers { get; }
  • public MetricsContextValueSource(string context, IEnumerable<GaugeValueSource> gauges, IEnumerable<CounterValueSource> counters, IEnumerable<MeterValueSource> meters, IEnumerable<HistogramValueSource> histograms, IEnumerable<TimerValueSource> timers, IEnumerable<ApdexValueSource> apdexScores)
  • public MetricsContextValueSource Filter(IFilterMetrics filter)
  • public bool IsNotEmpty()
• public static class MetricsContextValueSourceExtensions
  • public static T ValueFor<T>(this IEnumerable<MetricValueSourceBase<T>> values, string context, string metricName)
• public sealed class MetricsDataValueSource
  • public static readonly MetricsDataValueSource Empty
  • public IEnumerable<MetricsContextValueSource> Contexts { get; }
  • public EnvironmentInfo Environment { get; }
  • public DateTime Timestamp { get; }
  • public MetricsDataValueSource(DateTime timestamp, EnvironmentInfo environment, IEnumerable<MetricsContextValueSource> contexts)
  • public MetricsDataValueSource Filter(IFilterMetrics filter)
• public sealed class ScaledValueProvider<T> : IMetricValueProvider<T>
  • public T Value { get; }
  • public IMetricValueProvider<T> ValueProvider { get; }
  • public ScaledValueProvider(IMetricValueProvider<T> valueProvider, Func<T, T> transformation)
  • public T GetValue(bool resetMetric = false)
• public struct UserValueWrapper
  • public static readonly IComparer<UserValueWrapper> Comparer
  • public static readonly UserValueWrapper Empty
  • public string UserValue { get; }
  • public long Value { get; }
  • public UserValueWrapper(long value, string userValue = null)
  • public static bool op_Equality(UserValueWrapper left, UserValueWrapper right)
  • public static bool op_Inequality(UserValueWrapper left, UserValueWrapper right)
  • public bool Equals(UserValueWrapper other)

App.Metrics.Core.Abstractions

• public interface IBuildMetrics
  • IBuildApdexMetrics Apdex { get; }
  • IBuildCounterMetrics Counter { get; }
  • IBuildGaugeMetrics Gauge { get; }
  • IBuildHistogramMetrics Histogram { get; }
  • IBuildMeterMetrics Meter { get; }
  • IBuildTimerMetrics Timer { get; }
• public interface IManageMetrics
  • void Disable()
  • void Reset()
  • void ShutdownContext(string context)
• public interface IMeasureMetrics
  • IMeasureApdexMetrics Apdex { get; }
  • IMeasureCounterMetrics Counter { get; }
  • IMeasureGaugeMetrics Gauge { get; }
  • IMeasureHistogramMetrics Histogram { get; }
  • IMeasureMeterMetrics Meter { get; }
  • IMeasureTimerMetrics Timer { get; }
• public interface IMetricValueProvider<T>
  • T Value { get; }
  • T GetValue(bool resetMetric = false)
• public interface IProvideMetricValues
  • MetricsDataValueSource Get()
  • MetricsDataValueSource Get(IFilterMetrics overrideGlobalFilter)
  • MetricsContextValueSource GetForContext(string context)
• public interface IResetableMetric
  • void Reset()
• public abstract class MetricBase
  • public string Name { get; set; }
  • public MetricTags Tags { get; set; }
  • public string Unit { get; set; }
  • protected MetricBase()
• public abstract class MetricValueSourceBase<T>
  • public string Name { get; }
  • public MetricTags Tags { get; }
  • public Unit Unit { get; }
  • public T Value { get; }
  • public IMetricValueProvider<T> ValueProvider { get; }
  • protected MetricValueSourceBase(string name, IMetricValueProvider<T> valueProvider, Unit unit, MetricTags tags)

App.Metrics.Core.Interfaces

• public interface IHideObjectMembers
  • bool Equals(object obj)
  • int GetHashCode()
  • Type GetType()
  • string ToString()
• public interface IProvideMetrics
  • IProvideApdexMetrics Apdex { get; }
  • IProvideCounterMetrics Counter { get; }
  • IProvideGaugeMetrics Gauge { get; }
  • IProvideHistogramMetrics Histogram { get; }
  • IProvideMeterMetrics Meter { get; }
  • IProvideTimerMetrics Timer { get; }

App.Metrics.Core.Options

• public class ApdexOptions : MetricValueWithSamplingOption
  • public bool AllowWarmup { get; set; }
  • public double ApdexTSeconds { get; set; }
  • public bool ResetOnReporting { get; set; }
  • public ApdexOptions()
• public class CounterOptions : MetricValueOptionsBase
  • public bool ReportItemPercentages { get; set; }
  • public bool ReportSetItems { get; set; }
  • public bool ResetOnReporting { get; set; }
  • public CounterOptions()
• public class GaugeOptions : MetricValueOptionsBase
  • public GaugeOptions()
• public class HistogramOptions : MetricValueWithSamplingOption
  • public HistogramOptions()
• public class MeterOptions : MetricValueOptionsBase
  • public TimeUnit RateUnit { get; set; }
  • public MeterOptions()
• public abstract class MetricValueOptionsBase
  • public string Context { get; set; }
  • public Unit MeasurementUnit { get; set; }
  • public string Name { get; set; }
  • public MetricTags Tags { get; set; }
  • protected MetricValueOptionsBase()
• public abstract class MetricValueWithSamplingOption : MetricValueOptionsBase
  • public Lazy<IReservoir> Reservoir { get; set; }
  • protected MetricValueWithSamplingOption()
• public class TimerOptions : MetricValueWithSamplingOption
  • public TimeUnit DurationUnit { get; set; }
  • public TimeUnit RateUnit { get; set; }
  • public TimerOptions()

App.Metrics.Counter

• public static class CounterExtensions
  • public static CounterValue GetCounterValue(this IProvideMetricValues valueService, string context, string metricName)
  • public static CounterValue GetValueOrDefault(this ICounter metric)
  • public static IEnumerable<CounterMetric> ToMetric(this IEnumerable<CounterValueSource> source)
  • public static CounterMetric ToMetric(this CounterValueSource source)
  • public static CounterValueSource ToMetricValueSource(this CounterMetric source)
  • public static IEnumerable<CounterValueSource> ToMetricValueSource(this IEnumerable<CounterMetric> source)
• public sealed class CounterMetric : MetricBase
  • public sealed class SetItem
  • public long Count { get; set; }
  • public IEnumerable<SetItem> Items { get; set; }
  • public CounterMetric()
• public struct CounterValue
  • public struct SetItem
  • public static readonly IComparer<SetItem> SetItemComparer
  • public long Count { get; }
  • public SetItem[] Items { get; }
  • public CounterValue(long count, SetItem[] items)
  • public static bool op_Equality(CounterValue left, CounterValue right)
  • public static bool op_Inequality(CounterValue left, CounterValue right)
  • public bool Equals(CounterValue other)
• public sealed class CounterValueSource : MetricValueSourceBase<CounterValue>
  • public bool ReportItemPercentages { get; }
  • public bool ReportSetItems { get; }
  • public bool ResetOnReporting { get; }
  • public CounterValueSource(string name, IMetricValueProvider<CounterValue> value, Unit unit, MetricTags tags, bool resetOnReporting = false, bool reportItemPercentages = true, bool reportSetItems = true)
• public class DefaultCounterBuilder : IBuildCounterMetrics
  • public DefaultCounterBuilder()
  • public ICounterMetric Build()
  • public ICounterMetric Build<T>(Func<T> builder) where T : ICounterMetric
• public sealed class DefaultCounterMetric : ICounterMetric, ICounter, IResetableMetric, IMetricValueProvider<CounterValue>
  • public CounterValue Value { get; }
  • public DefaultCounterMetric()
  • public void Decrement()
  • public void Decrement(long value)
  • public void Decrement(string item)
  • public void Decrement(string item, long amount)
  • public void Decrement(MetricItem item)
  • public void Decrement(MetricItem item, long amount)
  • public CounterValue GetValue(bool resetMetric = false)
  • public void Increment()
  • public void Increment(long value)
  • public void Increment(string item)
  • public void Increment(string item, long amount)
  • public void Increment(MetricItem item)
  • public void Increment(MetricItem item, long amount)
  • public void Reset()
• public class DefaultCounterMetricProvider : IProvideCounterMetrics
  • public DefaultCounterMetricProvider(IBuildCounterMetrics counterBuilder, IMetricsRegistry registry)
  • public ICounter Instance<T>(CounterOptions options, Func<T> builder) where T : ICounterMetric
  • public ICounter Instance(CounterOptions options)

App.Metrics.Counter.Abstractions

• public interface IBuildCounterMetrics
  • ICounterMetric Build()
  • ICounterMetric Build<T>(Func<T> builder) where T : ICounterMetric
• public interface ICounter : IResetableMetric
  • void Decrement()
  • void Decrement(string item)
  • void Decrement(MetricItem item)
  • void Decrement(long amount)
  • void Decrement(string item, long amount)
  • void Decrement(MetricItem item, long amount)
  • void Increment()
  • void Increment(string item)
  • void Increment(MetricItem item)
  • void Increment(long amount)
  • void Increment(string item, long amount)
  • void Increment(MetricItem item, long amount)
• public interface IMeasureCounterMetrics
  • void Decrement(CounterOptions options)
  • void Decrement(CounterOptions options, long amount)
  • void Decrement(CounterOptions options, string item)
  • void Decrement(CounterOptions options, long amount, string item)
  • void Decrement(CounterOptions options, Action<MetricItem> item)
  • void Decrement(CounterOptions options, long amount, Action<MetricItem> item)
  • void Increment(CounterOptions options)
  • void Increment(CounterOptions options, long amount)
  • void Increment(CounterOptions options, string item)
  • void Increment(CounterOptions options, long amount, string item)
  • void Increment(CounterOptions options, Action<MetricItem> item)
  • void Increment(CounterOptions options, long amount, Action<MetricItem> item)
• public interface IProvideCounterMetrics
  • ICounter Instance(CounterOptions options)
  • ICounter Instance<T>(CounterOptions options, Func<T> builder) where T : ICounterMetric

App.Metrics.Data

• public static class MetricContextValueSourceEnumerableExtensions
  • public static IEnumerable<MetricsContextValueSource> FilterBy(this IEnumerable<MetricsContextValueSource> valueSources, IFilterMetrics filter)
  • public static IEnumerable<MetricsContextValueSource> WhereNotEmpty(this IEnumerable<MetricsContextValueSource> valueSources)

App.Metrics.Extensions

• public static class MetricContextExtensions
  • public static MetricsContext ToMetric(this MetricsContextValueSource source)
  • public static IEnumerable<MetricsContext> ToMetric(this IEnumerable<MetricsContextValueSource> source)
  • public static IEnumerable<MetricsContextValueSource> ToMetricValueSource(this IEnumerable<MetricsContext> source)
  • public static MetricsContextValueSource ToMetricValueSource(this MetricsContext source)
• public static class MetricDataExtensions
  • public static MetricData ToMetric(this MetricsDataValueSource source)
  • public static MetricsDataValueSource ToMetricValueSource(this MetricData source)

App.Metrics.Filtering

• public sealed class DefaultMetricsFilter : IFilterMetrics
  • public bool ReportEnvironment { get; }
  • public bool ReportHealthChecks { get; }
  • public DefaultMetricsFilter()
  • public bool IsApdexMatch(ApdexValueSource apdex)
  • public bool IsContextMatch(string context)
  • public bool IsCounterMatch(CounterValueSource counter)
  • public bool IsGaugeMatch(GaugeValueSource gauge)
  • public bool IsHistogramMatch(HistogramValueSource histogram)
  • public bool IsMeterMatch(MeterValueSource meter)
  • public bool IsTimerMatch(TimerValueSource timer)
  • public IFilterMetrics WhereContext(Predicate<string> condition)
  • public IFilterMetrics WhereContext(string context)
  • public IFilterMetrics WhereMetricName(Predicate<string> condition)
  • public IFilterMetrics WhereMetricNameStartsWith(string name)
  • public IFilterMetrics WhereMetricTaggedWithKey(string[] tagKeys)
  • public IFilterMetrics WhereMetricTaggedWithKeyValue(TagKeyValueFilter tags)
  • public IFilterMetrics WhereType(MetricType[] types)
  • public IFilterMetrics WithEnvironmentInfo(bool report)
  • public IFilterMetrics WithHealthChecks(bool report)
• public class TagKeyValueFilter : Dictionary<string, string>
  • public TagKeyValueFilter()

App.Metrics.Formatting.Humanize

• public sealed class HumanizeApdexScoreMetricFormatter : ICustomFormatter
  • public HumanizeApdexScoreMetricFormatter()
  • public string Format(string format, object arg, IFormatProvider formatProvider)
• public sealed class HumanizeCounterMetricFormatter : ICustomFormatter
  • public HumanizeCounterMetricFormatter()
  • public string Format(string format, object arg, IFormatProvider formatProvider)
• public sealed class HumanizeEnvironmentInfoFormatter : ICustomFormatter
  • public HumanizeEnvironmentInfoFormatter()
  • public string Format(string format, object arg, IFormatProvider formatProvider)
• public sealed class HumanizeGaugeMetricFormatter : ICustomFormatter
  • public HumanizeGaugeMetricFormatter()
  • public string Format(string format, object arg, IFormatProvider formatProvider)
• public sealed class HumanizeHealthCheckResultFormatter : ICustomFormatter
  • public HumanizeHealthCheckResultFormatter()
  • public string Format(string format, object arg, IFormatProvider formatProvider)
• public class HumanizeHistogramMetricFormatter : ICustomFormatter
  • public HumanizeHistogramMetricFormatter()
  • public string Format(string format, object arg, IFormatProvider formatProvider)
• public sealed class HumanizeMeterMetricFormatter : ICustomFormatter
  • public HumanizeMeterMetricFormatter()
  • public string Format(string format, object arg, IFormatProvider formatProvider)
• public static class HumanizeMetricValueExtensions
  • public static void HumanizeApdexScore(this StringBuilder sb, ApdexValueSource apdex)
  • public static void HumanizeCounter(this StringBuilder sb, CounterValueSource counter)
  • public static void HumanizeGauge(this StringBuilder sb, GaugeValueSource gauge)
  • public static void HumanizeHistogram(this StringBuilder sb, HistogramValue histogram, Unit unit)
  • public static void HumanizeMeter(this StringBuilder sb, MeterValue value, Unit unit)
  • public static void HummanizeTimer(this StringBuilder sb, TimerValueSource timer)
• public sealed class HumanizeMetricValueFormatProvider<T> : IFormatProvider
  • public HumanizeMetricValueFormatProvider()
  • public object GetFormat(Type formatType)
• public sealed class HumanizeTimerMetricFormatter : ICustomFormatter
  • public HumanizeTimerMetricFormatter()
  • public string Format(string format, object arg, IFormatProvider formatProvider)
• public static class HumanizingMetricsExtensions
  • public static string HumanzeEndMetricType(this Type metricType)
  • public static string HumanzeStartMetricType(this Type metricType, string context = null)
  • public static string HumanzizeName<T>(this MetricValueSourceBase<T> valueSource, string context = null)
  • public static string Hummanize<T>(this MetricValueSourceBase<T> valueSource)
  • public static string Hummanize(this EnvironmentInfo environmentInfo)
  • public static string Hummanize(this Result healthCheckResult)
• public static class HumanizingMetricsStringBuilderExtensions
  • public static void WriteDegradedHealthChecksHeader(this StringBuilder buffer)
  • public static void WriteEnvironmentInfo(this StringBuilder buffer, EnvironmentInfo environmentInfo)
  • public static void WriteFailedHealthChecksHeader(this StringBuilder buffer)
  • public static void WriteHealthCheckResult(this StringBuilder buffer, Result healthCheckResult)
  • public static void WriteHealthStatus(this StringBuilder buffer, string status)
  • public static void WriteMetricEndReport(this StringBuilder buffer, string reportName, string timeStamp)
  • public static void WriteMetricName<T>(this StringBuilder buffer, MetricValueSourceBase<T> valueSource, string context = null)
  • public static void WriteMetricStartReport(this StringBuilder buffer, string reportName, string timeStamp)
  • public static void WriteMetricValue<T>(this StringBuilder buffer, MetricValueSourceBase<T> valueSource)
  • public static void WritePassedHealthChecksHeader(this StringBuilder buffer)
  • public static void WriteStartMetricType(this StringBuilder buffer, Type metricType, string context = null)
• public static class MetricValueStringExtensions
  • public static string FormatReadableMetricValue(this string label, string value, string sign = "=")

App.Metrics.Gauge

• public class DefaultGaugeBuilder : IBuildGaugeMetrics
  • public DefaultGaugeBuilder()
  • public IGaugeMetric Build(Func<double> valueProvider)
• public class DefaultGaugeMetricProvider : IProvideGaugeMetrics
  • public DefaultGaugeMetricProvider(IMetricsRegistry registry)
  • public void Instance(GaugeOptions options, Func<IMetricValueProvider<double>> valueProvider)
• public sealed class DerivedGauge : IGaugeMetric, IMetricValueProvider<double>
  • public double Value { get; }
  • public DerivedGauge(IMetricValueProvider<double> gauge, Func<double, double> transformation)
  • public double GetValue(bool resetMetric = false)
• public class FunctionGauge : IGaugeMetric, IMetricValueProvider<double>
  • public double Value { get; }
  • public FunctionGauge(Func<double> valueProvider)
  • public double GetValue(bool resetMetric = false)
• public static class GaugeExtensions
  • public static double GetGaugeValue(this IProvideMetricValues valueService, string context, string metricName)
  • public static IEnumerable<GaugeMetric> ToMetric(this IEnumerable<GaugeValueSource> source)
  • public static GaugeMetric ToMetric(this GaugeValueSource source)
  • public static GaugeValueSource ToMetricValueSource(this GaugeMetric source)
  • public static IEnumerable<GaugeValueSource> ToMetricValueSource(this IEnumerable<GaugeMetric> source)
• public sealed class GaugeMetric : MetricBase
  • public double? Value { get; set; }
  • public GaugeMetric()
  • public static GaugeMetric FromGauge(MetricValueSourceBase<double> gauge)
• public sealed class GaugeValueSource : MetricValueSourceBase<double>
  • public GaugeValueSource(string name, IMetricValueProvider<double> value, Unit unit, MetricTags tags)
• public class HitPercentageGauge : PercentageGauge
  • public HitPercentageGauge(IMeter hitMeter, IMeter totalMeter)
  • public HitPercentageGauge(IMeter hitMeter, IMeter totalMeter, Func<MeterValue, double> meterRateFunc)
  • public HitPercentageGauge(IMeter hitMeter, ITimer totalTimer)
  • public HitPercentageGauge(IMeter hitMeter, ITimer totalTimer, Func<MeterValue, double> meterRateFunc)
• public sealed class HitRatioGauge : RatioGauge
  • public HitRatioGauge(IMeter hitMeter, IMeter totalMeter)
  • public HitRatioGauge(IMeter hitMeter, IMeter totalMeter, Func<MeterValue, double> meterRateFunc)
  • public HitRatioGauge(IMeter hitMeter, ITimer totalTimer)
  • public HitRatioGauge(IMeter hitMeter, ITimer totalTimer, Func<MeterValue, double> meterRateFunc)
• public class PercentageGauge : FunctionGauge
  • public PercentageGauge(Func<double> numerator, Func<double> denominator)
• public class RatioGauge : FunctionGauge
  • public RatioGauge(Func<double> numerator, Func<double> denominator)

App.Metrics.Gauge.Abstractions

• public interface IBuildGaugeMetrics
  • IGaugeMetric Build(Func<double> valueProvider)
• public interface IMeasureGaugeMetrics
  • void SetValue(GaugeOptions options, Func<IMetricValueProvider<double>> valueProvider)
  • void SetValue(GaugeOptions options, Func<double> valueProvider)
• public interface IProvideGaugeMetrics
  • void Instance(GaugeOptions options, Func<IMetricValueProvider<double>> valueProvider)

App.Metrics.Health

• public static class ApplicationHealthMetricRegistry
  • public static readonly string Context
  • public static CounterOptions DegradedCheckCounter { get; }
  • public static CounterOptions HealthyCheckCounter { get; }
  • public static CounterOptions UnhealthyCheckCounter { get; }
• public class HealthCheck
  • public struct Result
  • public string Name { get; }
  • public HealthCheck(string name, Func<Task<string>> check)
  • public HealthCheck(string name, Func<Task<HealthCheckResult>> check)
  • protected HealthCheck(string name)
  • protected virtual Task<HealthCheckResult> CheckAsync(CancellationToken cancellationToken = default)
  • public Task<Result> ExecuteAsync(CancellationToken cancellationToken = default)
• public struct HealthCheckResult
  • public readonly HealthCheckStatus Status
  • public string Message { get; }
  • public static HealthCheckResult Degraded(string message, object[] values)
  • public static HealthCheckResult Degraded(Exception exception)
  • public static HealthCheckResult Degraded()
  • public static HealthCheckResult Healthy()
  • public static HealthCheckResult Healthy(string message, object[] values)
  • public static HealthCheckResult Ignore()
  • public static HealthCheckResult Unhealthy()
  • public static HealthCheckResult Unhealthy(string message, object[] values)
  • public static HealthCheckResult Unhealthy(Exception exception)
• public enum HealthCheckStatus
  • Degraded = 1
  • Healthy = 0
  • Ignored = 3
  • Unhealthy = 2
• public static class HealthCheckStatusExtensions
  • public static bool IsDegraded(this HealthCheckStatus status)
  • public static bool IsHealthy(this HealthCheckStatus status)
  • public static bool IsIgnored(this HealthCheckStatus status)
  • public static bool IsUnhealthy(this HealthCheckStatus status)
• public struct HealthStatus
  • public bool HasRegisteredChecks { get; }
  • public Result[] Results { get; }
  • public HealthCheckStatus Status { get; }
  • public HealthStatus(IEnumerable<Result> results)
• public sealed class HealthStatusData
  • public Dictionary<string, string> Degraded { get; set; }
  • public Dictionary<string, string> Healthy { get; set; }
  • public string Status { get; set; }
  • public string Timestamp { get; set; }
  • public Dictionary<string, string> Unhealthy { get; set; }
  • public HealthStatusData()

App.Metrics.Health.Abstractions

• public interface IHealthCheckFactory
  • ConcurrentDictionary<string, HealthCheck> Checks { get; }
  • void Register(string name, Func<Task<string>> check)
  • void Register(string name, Func<Task<HealthCheckResult>> check)
• public interface IProvideHealth
  • Task<HealthStatus> ReadStatusAsync(CancellationToken cancellationToken = default)

App.Metrics.Histogram

• public class DefaultHistogramBuilder : IBuildHistogramMetrics
  • public DefaultHistogramBuilder(DefaultSamplingReservoirProvider defaultSamplingReservoirProvider)
  • public IHistogramMetric Build(Lazy<IReservoir> reservoir)
• public sealed class DefaultHistogramMetric : IHistogramMetric, IHistogram, IResetableMetric, IMetricValueProvider<HistogramValue>, IDisposable
  • public HistogramValue Value { get; }
  • public DefaultHistogramMetric(Lazy<IReservoir> reservoir)
  • public void Dispose()
  • public void Dispose(bool disposing)
  • public HistogramValue GetValue(bool resetMetric = false)
  • public void Reset()
  • public void Update(long value, string userValue)
  • public void Update(long value)
• public class DefaultHistogramMetricProvider : IProvideHistogramMetrics
  • public DefaultHistogramMetricProvider(IBuildHistogramMetrics histogramBuilder, IMetricsRegistry registry)
  • public IHistogram Instance(HistogramOptions options)
  • public IHistogram Instance<T>(HistogramOptions options, Func<T> builder) where T : IHistogramMetric
• public static class HistogramExtensions
  • public static HistogramValue GetHistogramValue(this IProvideMetricValues valueService, string context, string metricName)
  • public static HistogramValue GetValueOrDefault(this IHistogram metric)
  • public static IEnumerable<HistogramMetric> ToMetric(this IEnumerable<HistogramValueSource> source)
  • public static HistogramMetric ToMetric(this HistogramValueSource source)
  • public static HistogramValueSource ToMetricValueSource(this HistogramMetric source)
  • public static IEnumerable<HistogramValueSource> ToMetricValueSource(this IEnumerable<HistogramMetric> source)
• public sealed class HistogramMetric : MetricBase
  • public long Count { get; set; }
  • public string LastUserValue { get; set; }
  • public double LastValue { get; set; }
  • public double Max { get; set; }
  • public string MaxUserValue { get; set; }
  • public double Mean { get; set; }
  • public double Median { get; set; }
  • public double Min { get; set; }
  • public string MinUserValue { get; set; }
  • public double Percentile75 { get; set; }
  • public double Percentile95 { get; set; }
  • public double Percentile98 { get; set; }
  • public double Percentile99 { get; set; }
  • public double Percentile999 { get; set; }
  • public int SampleSize { get; set; }
  • public double StdDev { get; set; }
  • public HistogramMetric()
• public sealed class HistogramValue
  • public long Count { get; }
  • public string LastUserValue { get; }
  • public double LastValue { get; }
  • public double Max { get; }
  • public string MaxUserValue { get; }
  • public double Mean { get; }
  • public double Median { get; }
  • public double Min { get; }
  • public string MinUserValue { get; }
  • public double Percentile75 { get; }
  • public double Percentile95 { get; }
  • public double Percentile98 { get; }
  • public double Percentile99 { get; }
  • public double Percentile999 { get; }
  • public int SampleSize { get; }
  • public double StdDev { get; }
  • public HistogramValue(double lastValue, string lastUserValue, IReservoirSnapshot snapshot)
  • public HistogramValue(long count, double lastValue, string lastUserValue, double max, string maxUserValue, double mean, double min, string minUserValue, double stdDev, double median, double percentile75, double percentile95, double percentile98, double percentile99, double percentile999, int sampleSize)
  • public HistogramValue Scale(double factor)
• public sealed class HistogramValueSource : MetricValueSourceBase<HistogramValue>
  • public HistogramValueSource(string name, IMetricValueProvider<HistogramValue> valueProvider, Unit unit, MetricTags tags)

App.Metrics.Histogram.Abstractions

• public interface IBuildHistogramMetrics
  • IHistogramMetric Build(Lazy<IReservoir> reservoir)
• public interface IHistogram : IResetableMetric
  • void Update(long value, string userValue)
  • void Update(long value)
• public interface IMeasureHistogramMetrics
  • void Update(HistogramOptions options, long value)
  • void Update(HistogramOptions options, long value, string userValue)
• public interface IProvideHistogramMetrics
  • IHistogram Instance(HistogramOptions options)
  • IHistogram Instance<T>(HistogramOptions options, Func<T> builder) where T : IHistogramMetric

App.Metrics.Infrastructure

• public struct EnvironmentInfo
  • public static readonly EnvironmentInfo Empty
  • public IEnumerable<EnvironmentInfoEntry> Entries { get; }
  • public string EntryAssemblyName { get; }
  • public string EntryAssemblyVersion { get; }
  • public string HostName { get; }
  • public string LocalTimeString { get; }
  • public string MachineName { get; }
  • public string OperatingSystem { get; }
  • public string OperatingSystemVersion { get; }
  • public string ProcessName { get; }
  • public string ProcessorCount { get; }
  • public EnvironmentInfo(IDictionary<string, string> entries)
  • public EnvironmentInfo(string entryAssemblyName, string entryAssemblyVersion, string hostName, string localTimeString, string machineName, string operatingSystem, string operatingSystemVersion, string processName, string processorCount)
  • public static bool op_Equality(EnvironmentInfo left, EnvironmentInfo right)
  • public static bool op_Inequality(EnvironmentInfo left, EnvironmentInfo right)
  • public bool Equals(EnvironmentInfo other)
• public struct EnvironmentInfoEntry
  • public string Name { get; }
  • public string Value { get; }
  • public EnvironmentInfoEntry(string name, string value)
  • public static bool op_Equality(EnvironmentInfoEntry left, EnvironmentInfoEntry right)
  • public static bool op_Inequality(EnvironmentInfoEntry left, EnvironmentInfoEntry right)
  • public bool Equals(EnvironmentInfoEntry other)
• public static class EnvironmentInfoExtensions
  • public static IDictionary<string, string> ToEnvDictionary(this EnvironmentInfo environmentInfo)
• public sealed class EnvironmentInfoProvider
  • public EnvironmentInfoProvider()
  • public EnvironmentInfo Build()
• public interface IMetricsEnvironment
  • string ApplicationName { get; }
  • string ApplicationVersion { get; }
  • string RuntimeFramework { get; }
  • string RuntimeFrameworkVersion { get; }
• public sealed class MetricsAppEnvironment : IMetricsEnvironment
  • public string ApplicationName { get; }
  • public string ApplicationVersion { get; }
  • public string RuntimeFramework { get; }
  • public string RuntimeFrameworkVersion { get; }
  • public MetricsAppEnvironment(ApplicationEnvironment applicationEnvironment)
• public sealed class StopwatchClock : IClock
  • public long Nanoseconds { get; }
  • public long Seconds { get; }
  • public DateTime UtcDateTime { get; }
  • public event EventHandler Advanced
  • public StopwatchClock()
  • public void Advance(TimeUnit unit, long value)
  • public string FormatTimestamp(DateTime timestamp)
• public sealed class SystemClock : IClock
  • public long Nanoseconds { get; }
  • public long Seconds { get; }
  • public DateTime UtcDateTime { get; }
  • public event EventHandler Advanced
  • public SystemClock()
  • public void Advance(TimeUnit unit, long value)
  • public string FormatTimestamp(DateTime timestamp)
• public sealed class TestClock : IClock
  • public long Nanoseconds { get; }
  • public long Seconds { get; }
  • public DateTime UtcDateTime { get; }
  • public event EventHandler Advanced
  • public TestClock()
  • public void Advance(TimeUnit unit, long value)
  • public string FormatTimestamp(DateTime timestamp)

App.Metrics.Meter

• public class DefaultMeterBuilder : IBuildMeterMetrics
  • public DefaultMeterBuilder()
  • public IMeterMetric Build(IClock clock)
• public sealed class DefaultMeterMetric : SimpleMeter, IMeterMetric, IMeter, IResetableMetric, IMetricValueProvider<MeterValue>, IDisposable
  • public MeterValue Value { get; }
  • public DefaultMeterMetric(IClock systemClock)
  • public DefaultMeterMetric(IClock clock, IScheduler scheduler)
  • public void Dispose()
  • public void Dispose(bool disposing)
  • public MeterValue GetValue(bool resetMetric = false)
  • public void Mark()
  • public void Mark(string item)
  • public void Mark(MetricItem item)
  • public void Mark(MetricItem item, long amount)
  • public void Mark(string item, long amount)
• public class DefaultMeterMetricProvider : IProvideMeterMetrics
  • public DefaultMeterMetricProvider(IBuildMeterMetrics meterBuilder, IMetricsRegistry registry, IClock clock)
  • public IMeter Instance(MeterOptions options)
  • public IMeter Instance<T>(MeterOptions options, Func<T> builder) where T : IMeterMetric
• public sealed class MeterMetric : MetricBase
  • public sealed class SetItem
  • public long Count { get; set; }
  • public double FifteenMinuteRate { get; set; }
  • public double FiveMinuteRate { get; set; }
  • public IEnumerable<SetItem> Items { get; set; }
  • public double MeanRate { get; set; }
  • public double OneMinuteRate { get; set; }
  • public string RateUnit { get; set; }
  • public MeterMetric()
• public sealed class MeterValue
  • public struct SetItem
  • public static readonly IComparer<SetItem> SetItemComparer
  • public long Count { get; }
  • public double FifteenMinuteRate { get; }
  • public double FiveMinuteRate { get; }
  • public SetItem[] Items { get; }
  • public double MeanRate { get; }
  • public double OneMinuteRate { get; }
  • public TimeUnit RateUnit { get; }
  • public MeterValue(long count, double meanRate, double oneMinuteRate, double fiveMinuteRate, double fifteenMinuteRate, TimeUnit rateUnit, SetItem[] items)
  • public MeterValue Scale(TimeUnit unit)
• public sealed class MeterValueSource : MetricValueSourceBase<MeterValue>
  • public TimeUnit RateUnit { get; }
  • public MeterValueSource(string name, IMetricValueProvider<MeterValue> value, Unit unit, TimeUnit rateUnit, MetricTags tags)
• public class SimpleMeter
  • public SimpleMeter()
  • public MeterValue GetValue(double elapsed)
  • public virtual void Mark(long count)
  • public virtual void Reset()
  • public void Tick()

App.Metrics.Meter.Abstractions

• public interface IBuildMeterMetrics
  • IMeterMetric Build(IClock clock)
• public interface IMeasureMeterMetrics
  • void Mark(MeterOptions options, long amount)
  • void Mark(MeterOptions options)
  • void Mark(MeterOptions options, string item)
  • void Mark(MeterOptions options, Action<MetricItem> item)
  • void Mark(MeterOptions options, long amount, string item)
  • void Mark(MeterOptions options, long amount, Action<MetricItem> item)
• public interface IMeter : IResetableMetric
  • void Mark()
  • void Mark(string item)
  • void Mark(MetricItem item)
  • void Mark(MetricItem item, long amount)
  • void Mark(long amount)
  • void Mark(string item, long amount)
• public interface IProvideMeterMetrics
  • IMeter Instance(MeterOptions options)
  • IMeter Instance<T>(MeterOptions options, Func<T> builder) where T : IMeterMetric

App.Metrics.Meter.Extensions

• public static class MeterExtensions
  • public static MeterValue GetMeterValue(this IProvideMetricValues valueService, string context, string metricName)
  • public static MeterValue GetValueOrDefault(this IMeter metric)
  • public static IEnumerable<MeterMetric> ToMetric(this IEnumerable<MeterValueSource> source)
  • public static MeterMetric ToMetric(this MeterValueSource source)
  • public static MeterValueSource ToMetricValueSource(this MeterMetric source)
  • public static IEnumerable<MeterValueSource> ToMetricValueSource(this IEnumerable<MeterMetric> source)

App.Metrics.Registry.Abstractions

• public interface IMetricContextRegistry
  • string Context { get; }
  • IMetricRegistryManager DataProvider { get; }
  • IApdex Apdex<T>(ApdexOptions options, Func<T> builder) where T : IApdexMetric
  • void ClearAllMetrics()
  • ICounter Counter<T>(CounterOptions options, Func<T> builder) where T : ICounterMetric
  • void Gauge(GaugeOptions options, Func<IMetricValueProvider<double>> valueProvider)
  • IHistogram Histogram<T>(HistogramOptions options, Func<T> builder) where T : IHistogramMetric
  • IMeter Meter<T>(MeterOptions options, Func<T> builder) where T : IMeterMetric
  • ITimer Timer<T>(TimerOptions options, Func<T> builder) where T : ITimerMetric
• public interface IMetricRegistryManager
  • IEnumerable<ApdexValueSource> ApdexScores { get; }
  • IEnumerable<CounterValueSource> Counters { get; }
  • IEnumerable<GaugeValueSource> Gauges { get; }
  • IEnumerable<HistogramValueSource> Histograms { get; }
  • IEnumerable<MeterValueSource> Meters { get; }
  • IEnumerable<TimerValueSource> Timers { get; }
• public interface IMetricsRegistry
  • IApdex Apdex<T>(ApdexOptions options, Func<T> builder) where T : IApdexMetric
  • void Clear()
  • ICounter Counter<T>(CounterOptions options, Func<T> builder) where T : ICounterMetric
  • void Disable()
  • void Gauge(GaugeOptions options, Func<IMetricValueProvider<double>> valueProvider)
  • MetricsDataValueSource GetData(IFilterMetrics filter)
  • IHistogram Histogram<T>(HistogramOptions options, Func<T> builder) where T : IHistogramMetric
  • IMeter Meter<T>(MeterOptions options, Func<T> builder) where T : IMeterMetric
  • void RemoveContext(string context)
  • ITimer Timer<T>(TimerOptions options, Func<T> builder) where T : ITimerMetric

App.Metrics.Reporting

• public sealed class ReportFactory : IReportFactory
  • public ReportFactory(AppMetricsOptions options, IMetrics metrics, ILoggerFactory loggerFactory)
  • public void AddProvider(IReporterProvider provider)
  • public IReporter CreateReporter(IScheduler scheduler)
  • public IReporter CreateReporter()
• public sealed class StringReporter : IMetricReporter, IHideObjectMembers, IDisposable
  • public string Name { get; }
  • public TimeSpan ReportInterval { get; }
  • public string Result { get; }
  • public StringReporter()
  • public StringReporter(string name)
  • public void Dispose()
  • public void Dispose(bool disposing)
  • public Task<bool> EndAndFlushReportRunAsync(IMetrics metrics)
  • public void ReportEnvironment(EnvironmentInfo environmentInfo)
  • public void ReportHealth(GlobalMetricTags globalTags, IEnumerable<Result> healthyChecks, IEnumerable<Result> degradedChecks, IEnumerable<Result> unhealthyChecks)
  • public void ReportMetric<T>(string context, MetricValueSourceBase<T> valueSource)
  • public void StartReportRun(IMetrics metrics)

App.Metrics.Reporting.Abstractions

• public interface IReporter : IDisposable
  • void RunReports(IMetrics context, CancellationToken token)
• public interface IReportFactory
  • void AddProvider(IReporterProvider provider)
  • IReporter CreateReporter(IScheduler scheduler)
  • IReporter CreateReporter()

App.Metrics.Reporting.Internal

• public class DefaultReportGenerator
  • public DefaultReportGenerator(AppMetricsOptions options, ILoggerFactory loggerFactory)
  • public Task<bool> GenerateAsync(IMetricReporter reporter, IMetrics metrics, CancellationToken token)
  • public Task<bool> GenerateAsync(IMetricReporter reporter, IMetrics metrics, IFilterMetrics reporterMetricsFilter, CancellationToken token)

App.Metrics.ReservoirSampling

• public class DefaultSamplingReservoirProvider
  • public Func<Lazy<IReservoir>> Instance { get; }
  • public DefaultSamplingReservoirProvider()
  • public DefaultSamplingReservoirProvider(Func<Lazy<IReservoir>> instance)

App.Metrics.ReservoirSampling.ExponentialDecay

• public sealed class DefaultForwardDecayingReservoir : IReservoir, IDisposable
  • public int Size { get; }
  • public DefaultForwardDecayingReservoir()
  • public DefaultForwardDecayingReservoir(int sampleSize, double alpha)
  • public DefaultForwardDecayingReservoir(int sampleSize, double alpha, IClock clock, IScheduler scheduler)
  • public void Dispose()
  • public void Dispose(bool disposing)
  • public IReservoirSnapshot GetSnapshot(bool resetReservoir)
  • public IReservoirSnapshot GetSnapshot()
  • public void Reset()
  • public void Update(long value, string userValue)
  • public void Update(long value)
• public struct WeightedSample
  • public readonly string UserValue
  • public readonly long Value
  • public readonly double Weight
  • public WeightedSample(long value, string userValue, double weight)
  • public static bool op_Equality(WeightedSample left, WeightedSample right)
  • public static bool op_Inequality(WeightedSample left, WeightedSample right)
  • public bool Equals(WeightedSample other)
• public sealed class WeightedSnapshot : IReservoirSnapshot
  • public long Count { get; }
  • public long Max { get; }
  • public string MaxUserValue { get; }
  • public double Mean { get; }
  • public double Median { get; }
  • public long Min { get; }
  • public string MinUserValue { get; }
  • public double Percentile75 { get; }
  • public double Percentile95 { get; }
  • public double Percentile98 { get; }
  • public double Percentile99 { get; }
  • public double Percentile999 { get; }
  • public int Size { get; }
  • public double StdDev { get; }
  • public IEnumerable<long> Values { get; }
  • public WeightedSnapshot(long count, IEnumerable<WeightedSample> values)
  • public double GetValue(double quantile)

App.Metrics.ReservoirSampling.SlidingWindow

• public sealed class DefaultSlidingWindowReservoir : IReservoir
  • public DefaultSlidingWindowReservoir()
  • public DefaultSlidingWindowReservoir(int sampleSize)
  • public IReservoirSnapshot GetSnapshot(bool resetReservoir)
  • public IReservoirSnapshot GetSnapshot()
  • public void Reset()
  • public void Update(long value, string userValue)
  • public void Update(long value)

App.Metrics.ReservoirSampling.Uniform

• public sealed class DefaultAlgorithmRReservoir : IReservoir
  • public int Size { get; }
  • public DefaultAlgorithmRReservoir()
  • public DefaultAlgorithmRReservoir(int sampleSize)
  • public IReservoirSnapshot GetSnapshot(bool resetReservoir)
  • public IReservoirSnapshot GetSnapshot()
  • public void Reset()
  • public void Update(long value, string userValue)
  • public void Update(long value)
• public sealed class UniformSnapshot : IReservoirSnapshot
  • public long Count { get; }
  • public long Max { get; }
  • public string MaxUserValue { get; }
  • public double Mean { get; }
  • public double Median { get; }
  • public long Min { get; }
  • public string MinUserValue { get; }
  • public double Percentile75 { get; }
  • public double Percentile95 { get; }
  • public double Percentile98 { get; }
  • public double Percentile99 { get; }
  • public double Percentile999 { get; }
  • public int Size { get; }
  • public double StdDev { get; }
  • public IEnumerable<long> Values { get; }
  • public UniformSnapshot(long count, IEnumerable<long> values, bool valuesAreSorted = false, string minUserValue = null, string maxUserValue = null)
  • public double GetValue(double quantile)

App.Metrics.Scheduling

• public sealed class DefaultTaskScheduler : IScheduler, IDisposable
  • public DefaultTaskScheduler(bool allowMulitpleTasks = true)
  • public void Dispose()
  • public void Dispose(bool disposing)
  • public Task Interval(TimeSpan pollInterval, TaskCreationOptions taskCreationOptions, Action action)
  • public Task Interval(TimeSpan pollInterval, TaskCreationOptions taskCreationOptions, Action action, CancellationToken token)
  • public void Stop()

App.Metrics.Scheduling.Abstractions

• public interface IScheduler : IDisposable
  • Task Interval(TimeSpan pollInterval, TaskCreationOptions taskCreationOptions, Action action, CancellationToken token)
  • Task Interval(TimeSpan pollInterval, TaskCreationOptions taskCreationOptions, Action action)
  • void Stop()

App.Metrics.Serialization

• public sealed class NoOpHealthStatusSerializer : IHealthStatusSerializer
  • public NoOpHealthStatusSerializer()
  • public T Deserialize<T>(string json)
  • public string Serialize<T>(T value)
• public sealed class NoOpMetricDataSerializer : IMetricDataSerializer
  • public NoOpMetricDataSerializer()
  • public T Deserialize<T>(string json)
  • public string Serialize<T>(T value)

App.Metrics.Tagging

• public class GlobalMetricTags : Dictionary<string, string>
  • public GlobalMetricTags(Dictionary<string, string> tags)
  • public GlobalMetricTags()
• public sealed class MetricItem : ConcurrentDictionary<string, string>
  • public MetricItem()
  • public MetricItem With(string tag, string value)
• public class MetricTags : ConcurrentDictionary<string, string>
  • public static MetricTags None { get; }
  • public MetricTags(Dictionary<string, string> tags)
  • public MetricTags()
  • public MetricTags FromSetItemString(string setItem)
  • public MetricTags With(string tag, string value)

App.Metrics.Timer

• public class DefaultTimerBuilder : IBuildTimerMetrics
  • public DefaultTimerBuilder(DefaultSamplingReservoirProvider defaultSamplingReservoirProvider)
  • public ITimerMetric Build(IHistogramMetric histogram, IClock clock)
  • public ITimerMetric Build(Lazy<IReservoir> reservoir, IClock clock)
• public sealed class DefaultTimerMetric : ITimerMetric, ITimer, IResetableMetric, IMetricValueProvider<TimerValue>, IDisposable
  • public TimerValue Value { get; }
  • public DefaultTimerMetric(IHistogramMetric histogram, IClock clock)
  • public DefaultTimerMetric(Lazy<IReservoir> reservoir, IClock clock)
  • public DefaultTimerMetric(Lazy<IReservoir> reservoir, IMeterMetric meter, IClock clock)
  • public DefaultTimerMetric(IHistogramMetric histogram, IMeterMetric meter, IClock clock)
  • public long CurrentTime()
  • public void Dispose()
  • public void Dispose(bool disposing)
  • public long EndRecording()
  • public TimerValue GetValue(bool resetMetric = false)
  • public TimerContext NewContext(string userValue)
  • public TimerContext NewContext()
  • public void Record(long duration, TimeUnit unit, string userValue)
  • public void Record(long time, TimeUnit unit)
  • public void Reset()
  • public long StartRecording()
  • public void Time(Action action, string userValue)
  • public T Time<T>(Func<T> action, string userValue)
  • public void Time(Action action)
  • public T Time<T>(Func<T> action)
• public class DefaultTimerMetricProvider : IProvideTimerMetrics
  • public DefaultTimerMetricProvider(IBuildTimerMetrics timerBuilder, IMetricsRegistry registry, IClock clock)
  • public ITimer Instance(TimerOptions options)
  • public ITimer Instance<T>(TimerOptions options, Func<T> builder) where T : ITimerMetric
  • public ITimer WithHistogram<T>(TimerOptions options, Func<T> histogramMetricBuilder) where T : IHistogramMetric
• public struct TimerContext : IDisposable
  • public TimeSpan Elapsed { get; }
  • public TimerContext(ITimer timer, string userValue)
  • public void Dispose()
  • public void TrackUserValue(string value)
• public static class TimerExtensions
  • public static TimerValue GetTimerValue(this IProvideMetricValues valueService, string context, string metricName)
  • public static TimerValue GetValueOrDefault(this ITimer metric)
  • public static IEnumerable<TimerMetric> ToMetric(this IEnumerable<TimerValueSource> source)
  • public static TimerMetric ToMetric(this TimerValueSource source)
  • public static TimerValueSource ToMetricValueSource(this TimerMetric source)
  • public static IEnumerable<TimerValueSource> ToMetricValueSource(this IEnumerable<TimerMetric> source)
• public sealed class TimerMetric : MetricBase
  • public sealed class HistogramData
  • public sealed class RateData
  • public long ActiveSessions { get; set; }
  • public long Count { get; set; }
  • public string DurationUnit { get; set; }
  • public HistogramData Histogram { get; set; }
  • public RateData Rate { get; set; }
  • public string RateUnit { get; set; }
  • public long TotalTime { get; set; }
  • public TimerMetric()
• public sealed class TimerValue
  • public long ActiveSessions { get; }
  • public HistogramValue Histogram { get; }
  • public MeterValue Rate { get; }
  • public long TotalTime { get; }
  • public TimerValue(MeterValue rate, HistogramValue histogram, long activeSessions, long totalTime, TimeUnit durationUnit)
  • public TimerValue Scale(TimeUnit rate, TimeUnit duration)
• public sealed class TimerValueSource : MetricValueSourceBase<TimerValue>
  • public TimeUnit DurationUnit { get; }
  • public TimeUnit RateUnit { get; }
  • public TimerValueSource(string name, IMetricValueProvider<TimerValue> value, Unit unit, TimeUnit rateUnit, TimeUnit durationUnit, MetricTags tags)

App.Metrics.Timer.Abstractions

• public interface IBuildTimerMetrics
  • ITimerMetric Build(IHistogramMetric histogram, IClock clock)
  • ITimerMetric Build(Lazy<IReservoir> reservoir, IClock clock)
• public interface IMeasureTimerMetrics
  • void Time(TimerOptions options, Action action)
  • void Time(TimerOptions options, Action action, string userValue)
  • TimerContext Time(TimerOptions options, string userValue)
  • TimerContext Time(TimerOptions options)
• public interface IProvideTimerMetrics
  • ITimer Instance(TimerOptions options)
  • ITimer Instance<T>(TimerOptions options, Func<T> builder) where T : ITimerMetric
  • ITimer WithHistogram<T>(TimerOptions options, Func<T> histogramMetricBuilder) where T : IHistogramMetric
• public interface ITimer : IResetableMetric
  • long CurrentTime()
  • long EndRecording()
  • TimerContext NewContext(string userValue)
  • TimerContext NewContext()
  • void Record(long time, TimeUnit unit, string userValue)
  • void Record(long time, TimeUnit unit)
  • long StartRecording()
  • void Time(Action action, string userValue)
  • void Time(Action action)
  • T Time<T>(Func<T> action, string userValue)
  • T Time<T>(Func<T> action)

Microsoft.Extensions.DependencyInjection

• public interface IMetricsHostBuilder
  • IMetricsEnvironment Environment { get; }
  • IServiceCollection Services { get; }
• public static class MetricsHostBuilderExtensionsCore
  • public static IMetricsHostBuilder AddRequiredPlatformServices(this IMetricsHostBuilder builder)
• public static class MetricsHostBuilderExtensionsOptional
  • public static IMetricsHostBuilder AddClockType<T>(this IMetricsHostBuilder builder) where T : IClock
  • public static IMetricsHostBuilder AddDefaultReservoir(this IMetricsHostBuilder builder, Func<Lazy<IReservoir>> reservoirBuilder)
  • public static IMetricsHostBuilder AddGlobalFilter(this IMetricsHostBuilder builder, IFilterMetrics filter)
  • public static IMetricsHostBuilder AddHealthChecks(this IMetricsHostBuilder builder)
  • public static IMetricsHostBuilder AddHealthChecks(this IMetricsHostBuilder builder, Action<IHealthCheckFactory> setupAction)
  • public static IMetricsHostBuilder AddReporting(this IMetricsHostBuilder builder, Action<IReportFactory> setupAction)
• public static class MetricsServiceCollectionExtensions
  • public static IMetricsHostBuilder AddMetrics(this IServiceCollection services)
  • public static IMetricsHostBuilder AddMetrics(this IServiceCollection services, IConfiguration configuration)
  • public static IMetricsHostBuilder AddMetrics(this IServiceCollection services, Action<AppMetricsOptions> setupAction, IConfiguration configuration)
  • public static IMetricsHostBuilder AddMetrics(this IServiceCollection services, IConfiguration configuration, Action<AppMetricsOptions> setupAction)
  • public static IMetricsHostBuilder AddMetrics(this IServiceCollection services, Action<AppMetricsOptions> setupAction)