public sealed class MetricsCollector : IHostedService, IDisposable
{
    private readonly IMetrics _metrics;
    private readonly PeriodicTimer _periodicTimer;
    private readonly MeterListener _listener;
    private bool _disposed;

    public PostgreSqlMetricsCollector(IMetrics metrics)
    {
        _metrics = metrics;

        _listener = new MeterListener();
        _listener.InstrumentPublished = (instrument, listener) =>
        {
            if (instrument.Meter.Name == "Npgsql")
            {
                listener.EnableMeasurementEvents(instrument);
            }
        };

        _listener.SetMeasurementEventCallback<int>(HandleMeasurementEvent);
        _listener.SetMeasurementEventCallback<long>(HandleMeasurementEvent);
        _listener.SetMeasurementEventCallback<double>(HandleMeasurementEvent);

        _periodicTimer = new PeriodicTimer(new TimeSpan(0, 0, 5));
    }

    private void HandleMeasurementEvent<T>(Instrument instrument, T measurement, ReadOnlySpan<KeyValuePair<string, object?>> tags, object? state)
    {
        switch (instrument.Name)
        {
            case "db.client.commands.executing":
                _metrics.Measure.Counter.Increment(MetricsRegistry.CommandsExecuting, Convert.ToInt64(measurement));
                break;
            case "db.client.commands.failed":
                _metrics.Measure.Counter.Increment(MetricsRegistry.CommandsFailed, Convert.ToInt64(measurement));
                break;
            case "db.client.commands.duration":
                _metrics.Measure.Histogram.Update(MetricsRegistry.CommandsDuration, Convert.ToInt64(Convert.ToDouble(measurement) * 1000));
                break;
            case "db.client.commands.bytes_written":
                _metrics.Measure.Counter.Increment(MetricsRegistry.CommandsBytesWritten, Convert.ToInt64(measurement));
                break;
            case "db.client.commands.bytes_read":
                _metrics.Measure.Counter.Increment(MetricsRegistry.CommandsBytesRead, Convert.ToInt64(measurement));
                break;
            case "db.client.connections.pending_requests":
                _metrics.Measure.Counter.Increment(MetricsRegistry.ConnectionsPendingRequests, Convert.ToInt64(measurement));
                break;
            case "db.client.connections.timeouts":
                _metrics.Measure.Counter.Increment(MetricsRegistry.ConnectionsTimeouts, Convert.ToInt64(measurement));
                break;
            case "db.client.connections.create_time":
                _metrics.Measure.Histogram.Update(MetricsRegistry.ConnectionsCreateTime, Convert.ToInt64(Convert.ToDouble(measurement) * 1000));
                break;
            case "db.client.connections.usage":
                _metrics.Measure.Gauge.SetValue(MetricsRegistry.ConnectionsUsage, Convert.ToDouble(measurement));
                break;
            case "db.client.connections.max":
                _metrics.Measure.Gauge.SetValue(MetricsRegistry.ConnectionsMax, Convert.ToDouble(measurement));
                break;
            case "db.client.commands.prepared_ratio":
                _metrics.Measure.Gauge.SetValue(MetricsRegistry.CommandsPreparedRatio, Convert.ToDouble(measurement));
                break;
        }
    }

    public Task StartAsync(CancellationToken cancellationToken)
    {
        _listener.Start();

        _ = UpdateObservableMetrics(cancellationToken);

        return Task.CompletedTask;
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        Dispose(true);
        return Task.CompletedTask;
    }

    public async Task UpdateObservableMetrics(CancellationToken cancellationToken)
    {
        while (await _periodicTimer.WaitForNextTickAsync(cancellationToken))
        {
            _listener.RecordObservableInstruments();
        }
    }

    private void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                _listener.Dispose();
                _periodicTimer.Dispose();
            }

            _disposed = true;
        }
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
}