public void RegisterMetrics(ICollectorRegistry registry) { MetricFactory metricFactory = Prometheus.Metrics.WithCustomRegistry(registry); var counter = metricFactory.CreateCounter("gc_collect_count", "GC collection count", _lableNames.Union(new[] { "generation" }).ToArray()); for (var number = 0; number <= GC.MaxGeneration; number++) { _collectionCounts.Add(counter.Labels(_labelValues.Union(new[] { number.ToString() }).ToArray())); } _startTime = metricFactory .CreateGauge("start_time", "Start time of the process since unix epoch in seconds", _lableNames) .Labels(_labelValues); _cpuTotal = metricFactory.CreateCounter("cpu_seconds_total", "Total user and system CPU time spent in seconds", _lableNames).Labels(_labelValues); _virtualMemorySize = metricFactory.CreateGauge("virtual_bytes", "Process virtual memory size", _lableNames).Labels(_labelValues); _workingSet = metricFactory.CreateGauge("working_set", "Process working set", _lableNames).Labels(_labelValues); _privateMemorySize = metricFactory.CreateGauge("private_bytes", "Process private memory size", _lableNames).Labels(_labelValues); _openHandles = metricFactory.CreateGauge("open_handles", "Number of open handles", _lableNames).Labels(_labelValues); _numThreads = metricFactory.CreateGauge("num_threads", "Total number of threads", _lableNames).Labels(_labelValues); _pid = metricFactory.CreateGauge("processid", "Process ID", _lableNames).Labels(_labelValues); _totalMemory = metricFactory.CreateGauge("totalmemory", "Total known allocated memory", _lableNames).Labels(_labelValues); _startTime.Set((_process.StartTime.ToUniversalTime() - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)) .TotalSeconds); _pid.Set(_process.Id); }
public void RegisterMetrics(ICollectorRegistry registry) { registry.GetOrAdd(txBytes); registry.GetOrAdd(rxBytes); signal = Metrics.WithCustomRegistry(registry) .CreateGauge("CAPsMAN_Clients_Signal", "CAPsMAN Client's signal", "MAC", "IP", "Hostname"); }
public static async Task ProcessAsync(ICollectorRegistry registry, Stream outputStream) { using (var metricsWriter = new MetricsTextWriter(outputStream)) { await registry.CollectToAsync(metricsWriter).ConfigureAwait(false); } }
public void RegisterMetrics(ICollectorRegistry registry) { var metrics = Metrics.WithCustomRegistry(registry); var collectionCountsParent = metrics.CreateCounter("dotnet_collection_count_total", "GC collection count", new[] { "generation" }); for (var gen = 0; gen <= GC.MaxGeneration; gen++) { _collectionCounts.Add(collectionCountsParent.Labels(gen.ToString())); } // Metrics that make sense to compare between all operating systems // Keep the help text synchronized with the Go implementation to avoid pushgateway conflicts. // See https://github.com/prometheus/pushgateway/issues/194 // and https://github.com/prometheus-net/prometheus-net/issues/89 _startTime = metrics.CreateGauge("process_start_time_seconds", "Start time of the process since unix epoch in seconds."); _cpuTotal = metrics.CreateCounter("process_cpu_seconds_total", "Total user and system CPU time spent in seconds."); _virtualMemorySize = metrics.CreateGauge("process_windows_virtual_bytes", "Process virtual memory size"); _workingSet = metrics.CreateGauge("process_windows_working_set", "Process working set"); _privateMemorySize = metrics.CreateGauge("process_windows_private_bytes", "Process private memory size"); _openHandles = metrics.CreateGauge("process_windows_open_handles", "Number of open handles"); _numThreads = metrics.CreateGauge("process_windows_num_threads", "Total number of threads"); _pid = metrics.CreateGauge("process_windows_processid", "Process ID"); // .net specific metrics _totalMemory = metrics.CreateGauge("dotnet_totalmemory", "Total known allocated memory"); _perfErrors = metrics.CreateCounter("dotnet_collection_errors_total", "Total number of errors that occured during collections"); var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); _startTime.Set((_process.StartTime.ToUniversalTime() - epoch).TotalSeconds); _pid.Set(_process.Id); }
public MotorMetricsFactory( IOptions <PrometheusOptions> options, IApplicationNameService nameService ) { var prometheusConfig = options.Value ?? throw new ArgumentNullException(nameof(options), "Prometheus config doesn't exist."); _collectorRegistry = prometheusConfig.CollectorRegistryInstance ?? Prometheus.Client.Metrics.DefaultCollectorRegistry; _collectorRegistry.GetOrAdd( ThreadPoolGauge.ThreadPoolGaugeConfig, _ => new ThreadPoolGauge() ); _metricFactory = new MetricFactory(_collectorRegistry); var counter = _metricFactory.CreateCounter( "motor_extensions_hosting_build_info", "A metric with a constant '1' value labeled by version, libversion, and framework from which the service was built.", "version", "libversion", "framework" ); counter.WithLabels( nameService.GetVersion(), nameService.GetLibVersion(), RuntimeInformation.FrameworkDescription ).Inc(); }
public static void Process(ICollectorRegistry registry, Stream outputStream) { using (var metricsWriter = new MetricsTextWriter(outputStream)) { registry.CollectTo(metricsWriter); } }
public static ICollectorRegistry UseDotNetStats(this ICollectorRegistry registry, string prefixName) { registry.Add(new GCCollectionCountCollector(prefixName)); registry.Add(new GCTotalMemoryCollector(prefixName)); return(registry); }
public static ICollectorRegistry UseDefaultCollectors(this ICollectorRegistry registry, string prefixName) { registry.UseDotNetStats(prefixName); registry.UseProcessStats(prefixName); return(registry); }
public static ICollectorRegistry UseDefaultCollectors(this ICollectorRegistry registry) { registry.UseDotNetStats(); registry.UseProcessStats(); return(registry); }
public static ICollectorRegistry UseDotNetStats(this ICollectorRegistry registry) { registry.Add(nameof(GCCollectionCountCollector), new GCCollectionCountCollector()); registry.Add(nameof(GCTotalMemoryCollector), new GCTotalMemoryCollector()); return(registry); }
public MetricPusher(ICollectorRegistry collectorRegistry, string endpoint, string job, string instance, IEnumerable <KeyValuePair <string, string> > labels) { if (string.IsNullOrEmpty(job)) { throw new ArgumentNullException(nameof(job)); } if (string.IsNullOrEmpty(endpoint)) { throw new ArgumentNullException(nameof(endpoint)); } var stringBuilder = new StringBuilder(endpoint.TrimEnd('/') + "/metrics/job/" + job); if (!string.IsNullOrEmpty(instance)) { stringBuilder.Append("/instance/" + instance); } if (labels != null) { foreach (var pair in labels.Where(l => !string.IsNullOrEmpty(l.Key) && !string.IsNullOrEmpty(l.Value))) { stringBuilder.Append("/" + pair.Key + "/" + pair.Value); } } if (!Uri.TryCreate(stringBuilder.ToString(), UriKind.Absolute, out _targetUri)) { throw new ArgumentException("Endpoint must be a valid url", nameof(endpoint)); } _collectorRegistry = collectorRegistry ?? CollectorRegistry.Instance; _httpClient = new HttpClient(); }
public Startup(ICollectorRegistry _registry) { this._registry = _registry; var builder = new ConfigurationBuilder(); Configuration = builder.Build(); }
public MetricPusher(ICollectorRegistry collectorRegistry, string endpoint, string job, Dictionary <string, string> additionalHeaders, string instance, IEnumerable <KeyValuePair <string, string> > labels) { if (string.IsNullOrEmpty(job)) { throw new ArgumentNullException(nameof(job)); } if (string.IsNullOrEmpty(endpoint)) { throw new ArgumentNullException(nameof(endpoint)); } var stringBuilder = new StringBuilder(endpoint); if (!endpoint.EndsWith("/")) { stringBuilder.Append("/"); } stringBuilder .Append("metrics/job/") .Append(job); if (!string.IsNullOrEmpty(instance)) { stringBuilder .Append("/instance/") .Append(instance); } if (labels != null) { foreach (var pair in labels.Where(l => !string.IsNullOrEmpty(l.Key) && !string.IsNullOrEmpty(l.Value))) { stringBuilder .Append("/") .Append(pair.Key) .Append("/") .Append(pair.Value); } } if (!Uri.TryCreate(stringBuilder.ToString(), UriKind.Absolute, out _targetUri)) { throw new ArgumentException("Endpoint must be a valid url", nameof(endpoint)); } _collectorRegistry = collectorRegistry ?? CollectorRegistry.Instance; _httpClient = new HttpClient(); foreach (KeyValuePair <string, string> header in additionalHeaders) { _httpClient.DefaultRequestHeaders.Add( header.Key, header.Value ); } }
public MetricServer(string hostname, int port, string url = "metrics/", ICollectorRegistry registry = null) { _registry = registry ?? DefaultCollectorRegistry.Instance; _httpListener.Prefixes.Add(string.Format("http://{0}:{1}/{2}", hostname, port, url)); if (_registry == DefaultCollectorRegistry.Instance) { DefaultCollectorRegistry.Instance.RegisterStandardPerfCounters(); } }
public static MemoryStream Process(ICollectorRegistry registry) { // leave open var stream = new MemoryStream(); Process(registry, stream); stream.Position = 0; return(stream); }
public Startup(ICollectorRegistry registry, string url) { _registry = registry; _url = url; var builder = new ConfigurationBuilder(); Configuration = builder.Build(); }
public Startup(ICollectorRegistry registry, string mapPath) { _registry = registry; _mapPath = mapPath; var builder = new ConfigurationBuilder(); Configuration = builder.Build(); }
public static void Process(ICollectorRegistry registry, Stream outputStream) { using (var metricsWriter = new MetricsTextWriter(outputStream)) { foreach (var collector in registry.Enumerate()) { collector.Collect(metricsWriter); } } }
protected static Stream CollectionToStreamWriter(ICollectorRegistry registry) { var metrics = registry.CollectAll(); var stream = new MemoryStream(); ScrapeHandler.ProcessScrapeRequest(metrics, ContentType, stream); stream.Position = 0; return(stream); }
public static MemoryStream Process(ICollectorRegistry registry) { // leave open var stream = new MemoryStream(); var collected = registry.CollectAll(); TextFormatter.Format(stream, collected.ToArray()); stream.Position = 0; return(stream); }
protected void ResetFactories() { _registry = new CollectorRegistry(); _factory = new MetricFactory(_registry); _theirRegistry = Their.Prometheus.Metrics.NewCustomRegistry(); _theirMetricFactory = Their.Prometheus.Metrics.WithCustomRegistry(_theirRegistry); GC.Collect(); }
public MetricServer(string hostname, int port, string pathBase, IEnumerable <IOnDemandCollector> standardCollectors = null, ICollectorRegistry registry = null) : this(standardCollectors, registry) { _pathBase = pathBase; _hostAddress = $"http://{hostname}:{port}/"; }
public static async Task <MemoryStream> ProcessAsync(ICollectorRegistry registry) { // leave open var stream = new MemoryStream(); await ProcessAsync(registry, stream); stream.Position = 0; return(stream); }
/// <inheritdoc /> /// <summary> /// Constructor /// </summary> /// <param name="host">Host</param> /// <param name="port">Port</param> /// <param name="mapPath">Map Path: should start with '/'</param> /// <param name="registry">Collector registry</param> /// <param name="collectors">IOnDemandCollectors</param> /// <param name="useHttps">use Https</param> /// <param name="useDefaultCollectors">Use default collectors</param> public MetricServer(string host, int port, string mapPath, ICollectorRegistry registry, List <IOnDemandCollector> collectors, bool useHttps, bool useDefaultCollectors) : base(registry, collectors, useDefaultCollectors) { if (!mapPath.StartsWith("/")) { throw new ArgumentException($"mapPath '{mapPath}' should start with '/'"); } _httpListener.Prefixes.Add($"http{(useHttps ? "s" : "")}://{host}:{port}{mapPath.TrimEnd('/')}/"); }
/// <summary> /// Custom metrics server without basic auth /// </summary> public MetricsCustomServer(int port, string hostname = "localhost", string url = "metrics/", ICollectorRegistry registry = null, bool useHttps = false) { this.hostname = hostname; this.port = port; this.url = url; this.registry = registry; this.useHttps = useHttps; var s = useHttps ? "s" : ""; _httpListener.Prefixes.Add($"http{s}://{hostname}:{port}/{url}/"); _registry = registry ?? DefaultCollectorRegistry.Instance; }
/// <summary> /// Constructor /// </summary> /// <param name="registry">Collector registry</param> /// <param name="collectors">IOnDemandCollectors</param> /// <param name="useDefaultCollectors">Use default collectors</param> protected BaseMetricServer(ICollectorRegistry registry, List <IOnDemandCollector> collectors, bool useDefaultCollectors) { Registry = registry ?? CollectorRegistry.Instance; if (useDefaultCollectors) { var metricFactory = Registry == CollectorRegistry.Instance ? Metrics.DefaultFactory : new MetricFactory(Registry); collectors.AddRange(DefaultCollectors.Get(metricFactory)); } Registry.RegisterOnDemandCollectors(collectors); }
public static void CopyTo(this ICollectorRegistry registry, string collectorName, ICollectorRegistry destination) { if (destination == null) { throw new ArgumentNullException(nameof(destination)); } if (!registry.TryGet(collectorName, out var collector)) { throw new ArgumentOutOfRangeException(nameof(collectorName), collectorName, "Collector does not exist in the source registry"); } destination.Add(collector); }
public MetricServer(string hostname, int port, IEnumerable<IOnDemandCollector> standardCollectors = null, string url = "metrics/", ICollectorRegistry registry = null) { _registry = registry ?? DefaultCollectorRegistry.Instance; _httpListener.Prefixes.Add(string.Format("http://{0}:{1}/{2}", hostname, port, url)); if (_registry == DefaultCollectorRegistry.Instance) { // Default to DotNetStatsCollector if none speified // For no collectors, pass an empty collection if (standardCollectors == null) standardCollectors = new[] {new DotNetStatsCollector()}; DefaultCollectorRegistry.Instance.RegisterOnDemandCollectors(standardCollectors); } }
/// <inheritdoc /> /// <summary> /// Constructor /// </summary> /// <param name="host">Host</param> /// <param name="port">Port</param> /// <param name="mapPath">Map Path: Should strar with '/'</param> /// <param name="registry">Collector registry</param> /// <param name="collectors">IOnDemandCollectors</param> /// <param name="certificate">Certificate for Https</param> /// <param name="useDefaultCollectors">Use default collectors</param> public MetricServer(string host, int port, string mapPath, ICollectorRegistry registry, List <IOnDemandCollector> collectors, X509Certificate2 certificate, bool useDefaultCollectors) : base(registry, collectors, useDefaultCollectors) { if (!mapPath.StartsWith("/")) { throw new ArgumentException($"mapPath '{mapPath}' should start with '/'"); } _certificate = certificate; _port = port; _hostName = host; _mapPath = mapPath; }
private MetricServer(IEnumerable <IOnDemandCollector> standardCollectors = null, ICollectorRegistry registry = null) { _registry = registry ?? CollectorRegistry.Instance; if (_registry != CollectorRegistry.Instance) { return; } if (standardCollectors == null) { standardCollectors = new[] { new DotNetStatsCollector() }; } CollectorRegistry.Instance.RegisterOnDemandCollectors(standardCollectors); }
/// <summary> /// Constructor /// </summary> protected BaseMetricServer(IEnumerable <IOnDemandCollector> standardCollectors, ICollectorRegistry registry) { Registry = registry ?? CollectorRegistry.Instance; if (Registry != CollectorRegistry.Instance) { return; } if (standardCollectors != null) { _standardCollectors = standardCollectors; } CollectorRegistry.Instance.RegisterOnDemandCollectors(_standardCollectors); }
public static void MoveTo(this ICollectorRegistry registry, string collectorName, ICollectorRegistry destination) { if (destination == null) { throw new ArgumentNullException(nameof(destination)); } var collector = registry.Remove(collectorName); if (collector == null) { throw new ArgumentOutOfRangeException(nameof(collectorName), collectorName, "Collector does not exist in the source registry"); } destination.Add(collector); }
public MetricServer(int port, IEnumerable<IOnDemandCollector> standardCollectors = null, string url = "metrics/", ICollectorRegistry registry = null) : this("+", port, standardCollectors, url, registry) { }
public MetricFactory(ICollectorRegistry registry) { _registry = registry; }
public static MetricFactory WithCustomRegistry(ICollectorRegistry registry) { return new MetricFactory(registry); }
public MetricServer(int port, string url = "metrics/", ICollectorRegistry registry = null) : this("+", port, url, registry) { }