/// <summary>
/// Enables an endpoint which exposes metrics that can be consumed by Prometheus server
/// </summary>
/// <param name="app"></param>
/// <param name="endpoint">The endpoint where the metrics are exposed. /metrics by default</param>
/// <param name="collectorRegistry"></param>
public static void UsePrometheus(this IApplicationBuilder app, string endpoint = "/metrics", ICollectorRegistry collectorRegistry = null)
{
var registry = collectorRegistry ?? DefaultCollectorRegistry.Instance;
if (registry == DefaultCollectorRegistry.Instance)
{
DefaultCollectorRegistry.Instance.RegisterOnDemandCollectors(new[] { new DotNetStatsCollector() });
}
app.Map(endpoint, builder =>
{
builder.Run(context =>
{
var acceptHeaders = context.Request.Headers["Accept"];
var contentType = ScrapeHandler.GetContentType(acceptHeaders);
context.Response.ContentType = contentType;
using (var stream = context.Response.Body)
{
var collected = registry.CollectAll();
ScrapeHandler.ProcessScrapeRequest(collected, contentType, stream);
}
return(Task.FromResult(0));
});
});
}
public void Configure(IApplicationBuilder app)
{
app.Run(context =>
{
if (context.Request.Path == _url)
{
var response = context.Response;
var request = context.Request;
response.StatusCode = 200;
var acceptHeader = request.Headers["Accept"];
var contentType = ScrapeHandler.GetContentType(acceptHeader);
response.ContentType = contentType;
using (var outputStream = response.Body)
{
var collected = _registry.CollectAll();
ScrapeHandler.ProcessScrapeRequest(collected, contentType, outputStream);
}
return(Task.FromResult(true));
}
context.Response.StatusCode = 404;
return(Task.FromResult(true));
});
}
public static string GenerateOutput()
{
using (var outputStream = new MemoryStream())
{
var collected = DefaultCollectorRegistry.Instance.CollectAll();
ScrapeHandler.ProcessScrapeRequest(collected, "text/plain", outputStream);
return(Encoding.UTF8.GetString(outputStream.ToArray()));
}
}
public void should_send_metrics_and_get_success()
{
var memoryStream = new MemoryStream();
ScrapeHandler.ProcessScrapeRequest(_metrics.CollectAll(), null, memoryStream);
var expectedResult = Encoding.UTF8.GetString(memoryStream.ToArray());
Assert.Equal(expectedResult, _result);
}
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 void WriteMetrics(HttpListenerResponse response, string contentType, IEnumerable <MetricFamily> metricFamily)
{
using (var outputStream = response.OutputStream)
{
try
{
ScrapeHandler.ProcessScrapeRequest(metricFamily, contentType, outputStream);
}
catch (HttpListenerException) { }
}
}
/// <summary>
/// Add PrometheusServer request execution pipeline.
/// </summary>
public static IAppBuilder UsePrometheusServer(this IAppBuilder app, Action <PrometheusOptions> setupOptions)
{
var options = new PrometheusOptions();
setupOptions?.Invoke(options);
if (app == null)
{
throw new ArgumentNullException(nameof(app));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (!options.MapPath.StartsWith("/"))
{
throw new ArgumentException($"MapPath '{options.MapPath}' should start with '/'");
}
RegisterCollectors(options);
app.Map(options.MapPath, coreapp =>
{
coreapp.Run(async context =>
{
var req = context.Request;
var response = context.Response;
var acceptHeader = req.Headers.Get("Accept");
var acceptHeaders = acceptHeader?.Split(',');
var contentType = ScrapeHandler.GetContentType(acceptHeaders);
response.ContentType = contentType;
using (var outputStream = response.Body)
{
var collected = options.CollectorRegistryInstance.CollectAll();
ScrapeHandler.ProcessScrapeRequest(collected, contentType, outputStream);
}
await Task.FromResult(0).ConfigureAwait(false);
});
});
return(app);
}
public void WriteToStream(Stream stream)
{
_logger.Trace($"{nameof(MetricsHttpContent)}.{nameof(WriteToStream)}",
new LogItem("Event", "ProcessScrapeRequest"));
try
{
ScrapeHandler.ProcessScrapeRequest(_metrics, _contentType, stream);
}
catch (Exception ex)
{
_logger.Error($"{nameof(MetricsHttpContent)}.{nameof(WriteToStream)}",
new LogItem("Event", "ProcessScrapeRequest failed"),
new LogItem("Exception", ex.Message),
new LogItem("StackTrace", ex.StackTrace));
}
}
public void Index()
{
var response = HttpContext.Response;
var request = HttpContext.Request;
response.StatusCode = 200;
var acceptHeader = request.Headers["Accept"];
var contentType = ScrapeHandler.GetContentType(acceptHeader);
response.ContentType = contentType;
using (var outputStream = response.Body)
{
var collected = DefaultCollectorRegistry.Instance.CollectAll();
ScrapeHandler.ProcessScrapeRequest(collected, contentType, outputStream);
};
}
public IActionResult Get()
{
var registry = CollectorRegistry.Instance;
var acceptHeaders = Request.Headers["Accept"];
var contentType = ScrapeHandler.GetContentType(acceptHeaders);
Response.ContentType = contentType;
string content;
using (var outputStream = new MemoryStream())
{
var collected = registry.CollectAll();
ScrapeHandler.ProcessScrapeRequest(collected, contentType, outputStream);
content = Encoding.UTF8.GetString(outputStream.ToArray());
}
return(Ok(content));
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseStaticFiles();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
var collectorRegistry = DefaultCollectorRegistry.Instance;
collectorRegistry.RegisterOnDemandCollectors(new [] {
new DotNetStatsCollector()
});
app.Map("/metrics", appConfig => {
appConfig.Run(async context =>
{
var acceptHeader = context.Request.Headers["Accept"];
var contentType = ScrapeHandler.GetContentType(acceptHeader);
context.Response.ContentType = contentType;
using (var outputStream = context.Response.Body)
{
ScrapeHandler.ProcessScrapeRequest(collectorRegistry.CollectAll(),
contentType, outputStream);
}
await Task.FromResult(0).ConfigureAwait(false);
});
});
}
private static void GetMetrics(HttpContext httpContext)
{
var syncIoFeature = httpContext.Features.Get <IHttpBodyControlFeature>();
if (syncIoFeature != null)
{
syncIoFeature.AllowSynchronousIO = true;
}
var request = httpContext.Request;
var response = httpContext.Response;
var acceptHeaders = request.Headers["Accept"];
response.ContentType = ScrapeHandler.GetContentType(acceptHeaders);
response.StatusCode = (int)HttpStatusCode.OK;
using var outputStream = response.Body;
var collected = DefaultCollectorRegistry.Instance.CollectAll();
ScrapeHandler.ProcessScrapeRequest(collected, response.ContentType, outputStream);
}
private void StartListen()
{
_httpListener.Start();
IsRunning = true;
while (IsRunning)
{
try
{
var context = _httpListener.GetContext();
var request = context.Request;
var response = context.Response;
var inputStream = request.InputStream;
var encoding = request.ContentEncoding;
var reader = new StreamReader(inputStream, encoding);
reader.ReadToEnd();
response.StatusCode = 200;
var acceptHeader = request.Headers.Get("Accept");
var acceptHeaders = acceptHeader?.Split(',');
var contentType = ScrapeHandler.GetContentType(acceptHeaders);
response.ContentType = contentType;
using (var outputStream = response.OutputStream)
{
var collected = Registry.CollectAll();
ScrapeHandler.ProcessScrapeRequest(collected, contentType, outputStream);
}
}
catch (HttpListenerException ex)
{
Trace.WriteLine($"Error in MetricServer: {ex}");
}
}
}
public override void ProcessRequest(HttpContext context)
{
if (!CheckAuthentication(context))
{
return;
}
var request = context.Request;
var response = context.Response;
// This adapts prometheus-net's internal HTTP serving code
// Cribbed from http://www.erikojebo.se/Code/Details/792
var acceptHeader = request.Headers.Get("Accept");
var acceptHeaders = (acceptHeader ?? "").Split(',');
response.ContentType = ScrapeHandler.GetContentType(acceptHeaders);
response.ContentEncoding = System.Text.Encoding.UTF8;
ScrapeHandler.ProcessScrapeRequest(
DefaultCollectorRegistry.Instance.CollectAll(),
response.ContentType,
response.OutputStream
);
}
public void Get()
{
var registry = CollectorRegistry.Instance;
try
{
var acceptHeaders = Request.Headers["Accept"];
var contentType = ScrapeHandler.GetContentType(acceptHeaders);
Response.ContentType = contentType;
Response.StatusCode = 200;
var neighborLabels = new[] { "address", "connectionType" };
var numberOfAllTransactions = Metrics.CreateCounter("numberOfAllTransactions", "", neighborLabels);
var numberOfRandomTransactionRequests = Metrics.CreateCounter("numberOfRandomTransactionRequests", "", neighborLabels);
var numberOfNewTransactions = Metrics.CreateCounter("numberOfNewTransactions", "", neighborLabels);
var numberOfInvalidTransactions = Metrics.CreateCounter("numberOfInvalidTransactions", "", neighborLabels);
var numberOfSentTransactions = Metrics.CreateCounter("numberOfSentTransactions", "", neighborLabels);
if (TryGetNodeInfo(out var nodeInfo))
{
var latestMilestoneIndex = Metrics.CreateCounter("latestMilestoneIndex", "");
var latestSolidSubtangleMilestoneIndex = Metrics.CreateCounter("latestSolidSubtangleMilestoneIndex", "");
var numberOfNeighbors = Metrics.CreateCounter("numberOfNeighbors", "");
var numberOfTips = Metrics.CreateCounter("numberOfTips", "");
var numberOfTransactionsToRequest = Metrics.CreateCounter("numberOfTransactionsToRequest", "");
latestMilestoneIndex.Inc(nodeInfo.LatestMilestoneIndex);
latestSolidSubtangleMilestoneIndex.Inc(nodeInfo.LatestSolidSubtangleMilestoneIndex);
numberOfNeighbors.Inc(nodeInfo.Neighbors);
numberOfTips.Inc(nodeInfo.Tips);
numberOfTransactionsToRequest.Inc(nodeInfo.TransactionsToRequest);
}
if (TryGetNeighbors(out var neighborsResponse))
{
foreach (var neighbor in neighborsResponse.Neighbors)
{
numberOfAllTransactions.Labels(neighbor.Address, neighbor.ConnectionType)
.Inc(neighbor.NumberOfAllTransactions);
numberOfRandomTransactionRequests.Labels(neighbor.Address, neighbor.ConnectionType)
.Inc(neighbor.NumberOfRandomTransactionRequests);
numberOfNewTransactions.Labels(neighbor.Address, neighbor.ConnectionType)
.Inc(neighbor.NumberOfNewTransactions);
numberOfInvalidTransactions.Labels(neighbor.Address, neighbor.ConnectionType)
.Inc(neighbor.NumberOfInvalidTransactions);
numberOfSentTransactions.Labels(neighbor.Address, neighbor.ConnectionType)
.Inc(neighbor.NumberOfSentTransactions);
}
}
using (var outputStream = Response.Body)
{
var collected = registry.CollectAll();
ScrapeHandler.ProcessScrapeRequest(collected, contentType, outputStream);
}
}
catch (Exception e)
{
Console.Error.WriteLine(e.ToString());
}
finally
{
registry.Clear();
}
}
/// <summary>
/// Push metrics to single pushgateway endpoint
/// </summary>
/// <param name="metrics">Collection of metrics</param>
/// <param name="endpoints">PushGateway endpoints - fault-tolerance</param>
/// <param name="job">job name</param>
/// <param name="instance">instance name</param>
/// <param name="contentType">content-type</param>
/// <returns></returns>
public async Task PushAsync(IEnumerable <CMetricFamily> metrics, string[] endpoints, string job, string instance, string contentType)
{
if (_httpClient == null)
{
_httpClient = new HttpClient();
}
var cntType = ContentType;
if (!string.IsNullOrEmpty(contentType))
{
cntType = contentType;
}
if (string.IsNullOrEmpty(job))
{
throw new ArgumentNullException(nameof(job));
}
var tasks = new List <Task <HttpResponseMessage> >(endpoints.Length);
var streamsToDispose = new List <Stream>();
foreach (var endpoint in endpoints)
{
var memoryStream = new MemoryStream();
streamsToDispose.Add(memoryStream);
ScrapeHandler.ProcessScrapeRequest(metrics, cntType, memoryStream);
memoryStream.Position = 0;
var debugString = Encoding.UTF8.GetString(memoryStream.ToArray());
System.Diagnostics.Debug.WriteLine(debugString);
if (string.IsNullOrEmpty(endpoint))
{
throw new ArgumentNullException(nameof(endpoint));
}
var url = $"{endpoint.TrimEnd('/')}/metrics/job/{job}";
if (!string.IsNullOrEmpty(instance))
{
url = $"{url}/instance/{instance}";
}
if (!Uri.TryCreate(url, UriKind.Absolute, out var targetUrl))
{
throw new ArgumentException("Endpoint must be a valid url", nameof(endpoint));
}
var streamContent = new StreamContent(memoryStream);
tasks.Add(_httpClient.PostAsync(targetUrl, streamContent));
}
await Task.WhenAll(tasks).ConfigureAwait(false);
Exception exception = null;
foreach (var task in tasks)
{
var response = await task.ConfigureAwait(false);
try
{
response.EnsureSuccessStatusCode();
}
catch (Exception ex)
{
exception = ex;
}
}
streamsToDispose.ForEach(s => s.Dispose());
if (exception != null)
{
throw exception;
}
}
private Task StartServer(CancellationToken cancel)
{
_httpListener.Start();
return(Task.Factory.StartNew(delegate
{
try
{
while (!cancel.IsCancellationRequested)
{
var getContext = _httpListener.GetContextAsync();
getContext.Wait(cancel);
var context = getContext.Result;
var request = context.Request;
var response = context.Response;
try
{
if (authMode == "None" || CheckAuthenticate(context))
{
IEnumerable <MetricFamily> metrics;
metrics = _registry.CollectAll();
var acceptHeader = request.Headers.Get("Accept");
var acceptHeaders = acceptHeader?.Split(',');
var contentType = ScrapeHandler.GetContentType(acceptHeaders);
response.ContentType = contentType;
response.StatusCode = 200;
using (var outputStream = response.OutputStream)
ScrapeHandler.ProcessScrapeRequest(metrics, contentType, outputStream);
}
else
{
throw new InvalidHeader();
}
}
catch (InvalidHeader ex)
{
response.StatusCode = 404;
//tell something about invalid header
}
catch (Exception ex) when(!(ex is OperationCanceledException))
{
Trace.WriteLine(string.Format("Error in MetricsServer: {0}", ex));
response.StatusCode = 404;
}
finally
{
response.Close();
}
}
}
finally
{
_httpListener.Stop();
_httpListener.Close();
}
}, TaskCreationOptions.LongRunning));
}