Appmetrics C#（开发人员如何使用）

public void ConfigureServices(IServiceCollection services)
{
    services.AddMetrics(); // Add basic metrics services
    services.AddMetricsTrackingMiddleware(); // Enable middleware for tracking
    services.AddMetricsEndpoints(); // Add endpoints for metrics exposure
}

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	services.AddMetrics() ' Add basic metrics services
	services.AddMetricsTrackingMiddleware() ' Enable middleware for tracking
	services.AddMetricsEndpoints() ' Add endpoints for metrics exposure
End Sub

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseMetricsAllMiddleware(); // Register the middleware to capture all metrics
}

Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
	app.UseMetricsAllMiddleware() ' Register the middleware to capture all metrics
End Sub

public class LoginTracker
{
    private readonly IMetrics _metrics;

    public LoginTracker(IMetrics metrics)
    {
        _metrics = metrics;
    }

    public void TrackLogin(string userId)
    {
        // Increment login counter for the specified user ID
        _metrics.Measure.Counter.Increment(MetricsRegistry.Logins, new MetricTags("UserId", userId));
    }
}

Public Class LoginTracker
	Private ReadOnly _metrics As IMetrics

	Public Sub New(ByVal metrics As IMetrics)
		_metrics = metrics
	End Sub

	Public Sub TrackLogin(ByVal userId As String)
		' Increment login counter for the specified user ID
		_metrics.Measure.Counter.Increment(MetricsRegistry.Logins, New MetricTags("UserId", userId))
	End Sub
End Class

public void ProcessData()
{
    // Measure time taken by the database query process
    using (_metrics.Measure.Timer.Time(MetricsRegistry.DatabaseQueryTimer))
    {
        // Code to execute a database query goes here
    }
}

Public Sub ProcessData()
	' Measure time taken by the database query process
	Using _metrics.Measure.Timer.Time(MetricsRegistry.DatabaseQueryTimer)
		' Code to execute a database query goes here
	End Using
End Sub

public void ConfigureServices(IServiceCollection services)
{
    services.AddMetricsReportingHostedService();
    services.AddMetrics(builder =>
    {
        builder.Report.ToInfluxDb(options =>
        {
            options.InfluxDb.BaseUri = new Uri("http://your-influxdb-server"); // Configure InfluxDB server URI
            options.InfluxDb.Database = "appmetricsdb"; // Specify the database name
            options.InfluxDb.UserName = "user"; // Set database username
            options.InfluxDb.Password = "password"; // Set database password
            options.HttpPolicy.BackoffPeriod = TimeSpan.FromSeconds(30); // Set backoff period
            options.HttpPolicy.FailuresBeforeBackoff = 5; // Set failure count before backoff
            options.HttpPolicy.Timeout = TimeSpan.FromSeconds(10); // Set HTTP timeout duration
            options.FlushInterval = TimeSpan.FromSeconds(5); // Set interval for reporting metrics
        });
    });
}

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	services.AddMetricsReportingHostedService()
	services.AddMetrics(Sub(builder)
		builder.Report.ToInfluxDb(Sub(options)
			options.InfluxDb.BaseUri = New Uri("http://your-influxdb-server") ' Configure InfluxDB server URI
			options.InfluxDb.Database = "appmetricsdb" ' Specify the database name
			options.InfluxDb.UserName = "user" ' Set database username
			options.InfluxDb.Password = "password" ' Set database password
			options.HttpPolicy.BackoffPeriod = TimeSpan.FromSeconds(30) ' Set backoff period
			options.HttpPolicy.FailuresBeforeBackoff = 5 ' Set failure count before backoff
			options.HttpPolicy.Timeout = TimeSpan.FromSeconds(10) ' Set HTTP timeout duration
			options.FlushInterval = TimeSpan.FromSeconds(5) ' Set interval for reporting metrics
		End Sub)
	End Sub)
End Sub

public void CheckSystemMemory()
{
    var freeMemory = GC.GetTotalMemory(false); // Get total free memory
    _metrics.Measure.Gauge.SetValue(MetricsRegistry.FreeMemory, freeMemory); // Set gauge to measure free memory
}

Public Sub CheckSystemMemory()
	Dim freeMemory = GC.GetTotalMemory(False) ' Get total free memory
	_metrics.Measure.Gauge.SetValue(MetricsRegistry.FreeMemory, freeMemory) ' Set gauge to measure free memory
End Sub

public void ConfigureScheduledReporting(IApplicationBuilder app)
{
    var metrics = app.ApplicationServices.GetService<IMetricsRoot>(); // Retrieve the IMetricsRoot instance
    var scheduler = new AppMetricsTaskScheduler(
        TimeSpan.FromSeconds(60), // Set the interval for metrics collection
        async () =>
        {
            await Task.WhenAll(metrics.ReportRunner.RunAllAsync()); // Run all reports asynchronously
        });
    scheduler.Start(); // Start the scheduler
}

Public Sub ConfigureScheduledReporting(ByVal app As IApplicationBuilder)
	Dim metrics = app.ApplicationServices.GetService(Of IMetricsRoot)() ' Retrieve the IMetricsRoot instance
	Dim scheduler = New AppMetricsTaskScheduler(TimeSpan.FromSeconds(60), Async Sub()
			Await Task.WhenAll(metrics.ReportRunner.RunAllAsync()) ' Run all reports asynchronously
	End Sub)
	scheduler.Start() ' Start the scheduler
End Sub

using App.Metrics;
using App.Metrics.Formatters.Prometheus;
using IronPdf;
public class MetricsToPdfConverter
{
    private readonly IMetricsRoot _metrics;

    public MetricsToPdfConverter(IMetricsRoot metrics)
    {
        _metrics = metrics;
    }

    public void GeneratePdfReport(string outputPath)
    {
        // Step 1: Capture the metrics snapshot
        var metricsData = _metrics.Snapshot.Get();
        var formatter = new MetricsPrometheusTextOutputFormatter();
        using var stream = new MemoryStream();
        formatter.WriteAsync(stream, metricsData).Wait();

        // Step 2: Convert the metrics snapshot to string format
        stream.Position = 0;
        var reader = new StreamReader(stream);
        var metricsText = reader.ReadToEnd();

        // Step 3: Use IronPDF to convert the metrics text to a PDF document
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1> Metrics Report </h1> <pre>" + metricsText + "</pre>");

        // Step 4: Save the PDF document
        pdf.SaveAs(outputPath);
    }
}

// Usage
var metrics = new MetricsBuilder().Build();
var pdfConverter = new MetricsToPdfConverter(metrics);
pdfConverter.GeneratePdfReport("MonthlyPerformanceReport.pdf");

Imports App.Metrics
Imports App.Metrics.Formatters.Prometheus
Imports IronPdf
Public Class MetricsToPdfConverter
	Private ReadOnly _metrics As IMetricsRoot

	Public Sub New(ByVal metrics As IMetricsRoot)
		_metrics = metrics
	End Sub

	Public Sub GeneratePdfReport(ByVal outputPath As String)
		' Step 1: Capture the metrics snapshot
		Dim metricsData = _metrics.Snapshot.Get()
		Dim formatter = New MetricsPrometheusTextOutputFormatter()
		Dim stream = New MemoryStream()
		formatter.WriteAsync(stream, metricsData).Wait()

		' Step 2: Convert the metrics snapshot to string format
		stream.Position = 0
		Dim reader = New StreamReader(stream)
		Dim metricsText = reader.ReadToEnd()

		' Step 3: Use IronPDF to convert the metrics text to a PDF document
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf("<h1> Metrics Report </h1> <pre>" & metricsText & "</pre>")

		' Step 4: Save the PDF document
		pdf.SaveAs(outputPath)
	End Sub
End Class

' Usage
Private metrics = (New MetricsBuilder()).Build()
Private pdfConverter = New MetricsToPdfConverter(metrics)
pdfConverter.GeneratePdfReport("MonthlyPerformanceReport.pdf")