RuntimeProfiler.cs

using System.Collections.ObjectModel;
using System.Diagnostics;
 
namespace Gondwana.Diagnostics;

public sealed class RuntimeProfiler : IDisposable
{
    private readonly object _sync = new();
    private readonly Func<double> _clock;
    private readonly Dictionary<long, TelemetrySource> _sources = [];
    private Queue<TelemetrySnapshot> _history = new(120);
    private TelemetrySnapshot? _latestSnapshot;
    private TelemetryOptions _options = new();
    private long _nextId, _generation;
    private int _requests;
    private bool _disposed, _truncated;
    private double _started;

    public RuntimeProfiler() : this(() => Stopwatch.GetTimestamp() / (double)Stopwatch.Frequency) { }

    internal RuntimeProfiler(Func<double> clock) => _clock = clock;

    public bool IsCollecting => Volatile.Read(ref _requests) != 0;

    public TelemetryOptions Options { get { lock (_sync) return _options; } }

    public void Configure(TelemetryOptions options)
    {
        ArgumentNullException.ThrowIfNull(options);
        options.Validate();
        lock (_sync)
        {
            ObjectDisposedException.ThrowIf(_disposed, this);
            if (_requests != 0) throw new InvalidOperationException("Configure telemetry while inactive.");
            if (_sources.Count > options.SourceCapacity || _sources.Values.Any(s => s.Metrics.Count > options.MetricCapacity))
                throw new InvalidOperationException("Configured limits are smaller than registered detail.");
            _options = options;
            _history = new Queue<TelemetrySnapshot>(options.HistoryCapacity);
            ResetCore();
        }
    }

    public IDisposable Start()
    {
        lock (_sync)
        {
            ObjectDisposedException.ThrowIf(_disposed, this);
            if (_requests == 0)
            {
                _generation++;
                _started = _clock();
                ClearAccumulators();
                foreach (var source in _sources.Values)
                    foreach (var accumulator in source.Metrics.Values) accumulator.Rebase();
            }
            _requests++;
            return new Request(this);
        }
    }

    public TelemetrySource? RegisterSource(string name, string backend)
    {
        ValidateName(name);
        ValidateName(backend);
        lock (_sync)
        {
            ObjectDisposedException.ThrowIf(_disposed, this);
            if (_sources.Count >= _options.SourceCapacity) { _truncated = true; return null; }
            var source = new TelemetrySource(this, ++_nextId, name, backend);
            _sources.Add(source.Id, source);
            return source;
        }
    }

    internal TelemetrySource? TryRegisterSource(string name, string backend)
    {
        lock (_sync)
            return _disposed ? null : RegisterSource(name, backend);
    }

    public TelemetrySnapshot? GetLatestSnapshot()
    {
        lock (_sync)
        {
            Advance();
            return _latestSnapshot;
        }
    }

    public IReadOnlyList<TelemetrySnapshot> GetHistory()
    {
        lock (_sync)
        {
            Advance();
            return Array.AsReadOnly(_history.ToArray());
        }
    }

    public void Reset() { lock (_sync) { ObjectDisposedException.ThrowIf(_disposed, this); ResetCore(); } }

    public void Dispose()
    {
        lock (_sync)
        {
            if (_disposed) return;
            _disposed = true;
            _requests = 0;
            _generation++;
            _sources.Clear();
            _history.Clear();
            _latestSnapshot = null;
        }
    }

    internal long Begin() => IsCollecting ? Volatile.Read(ref _generation) : 0;

    internal bool Define(TelemetrySource source, string name, TelemetryAvailability availability, TelemetryMetricKind kind)
    {
        ValidateName(name);
        lock (_sync)
        {
            if (!_sources.ContainsKey(source.Id)) return false;
            if (source.Metrics.TryGetValue(name, out var existing))
            {
                if (existing.Availability == TelemetryAvailability.Unsupported && availability == TelemetryAvailability.NotYetSampled)
                    existing.Availability = availability;
                return true;
            }
            if (source.Metrics.Count >= _options.MetricCapacity) { _truncated = true; return false; }
            source.Metrics.Add(name, new Accumulator { Availability = availability, Kind = kind });
            return true;
        }
    }

    internal void Record(TelemetrySource source, long generation, string metric, double value)
    {
        if (generation == 0 || !IsCollecting || !double.IsFinite(value)) return;
        lock (_sync)
        {
            if (_requests == 0 || generation != _generation || !_sources.ContainsKey(source.Id)) return;
            Advance();
            if (!source.Metrics.TryGetValue(metric, out var accumulator)) return;
            if (accumulator.Availability is TelemetryAvailability.Unsupported or TelemetryAvailability.NotApplicable) return;
            accumulator.Add(value, _clock());
        }
    }

    internal void Retire(TelemetrySource source) { lock (_sync) _sources.Remove(source.Id); }

    internal void MarkTruncated(long generation)
    {
        lock (_sync) { if (generation == _generation && _requests != 0) _truncated = true; }
    }
 
    private static void ValidateName(string name)
    {
        if (string.IsNullOrWhiteSpace(name) || name.Length > 96) throw new ArgumentException("Names must contain 1–96 characters.", nameof(name));
    }
 
    private void ResetCore()
    {
        _generation++;
        _history.Clear();
        _latestSnapshot = null;
        _started = _clock();
        ClearAccumulators();
        foreach (var source in _sources.Values)
            foreach (var accumulator in source.Metrics.Values) accumulator.Rebase();
    }
 
    private void ClearAccumulators()
    {
        foreach (var source in _sources.Values)
            foreach (var accumulator in source.Metrics.Values) accumulator.Clear();
    }
 
    private void Advance()
    {
        if (_requests == 0) return;
        double now = _clock();
        if (now - _started >= _options.Interval.TotalSeconds) Publish(now);
    }
 
    private void Publish(double now)
    {
        var sources = _sources.Values.Select(source => new TelemetrySourceSnapshot(source.Id, source.Name, source.Backend,
            new ReadOnlyDictionary<string, TelemetrySummary>(source.Metrics.ToDictionary(p => p.Key, p => p.Value.Snapshot())))).ToArray();
        if (_history.Count == _options.HistoryCapacity) _history.Dequeue();
        _latestSnapshot = new(_generation, _started, now, Array.AsReadOnly(sources), _truncated);
        _history.Enqueue(_latestSnapshot);
        ClearAccumulators();
        _started = now;
    }
 
    private void Stop()
    {
        lock (_sync)
        {
            if (_requests == 0) return;
            if (_requests == 1)
            {
                double now = _clock();
                if (now > _started) Publish(now);
                _generation++;
            }
            _requests--;
        }
    }
 
    private sealed class Request(RuntimeProfiler owner) : IDisposable
    {
        private RuntimeProfiler? _owner = owner;
        public void Dispose() => Interlocked.Exchange(ref _owner, null)?.Stop();
    }

    internal sealed class Accumulator
    {
        internal TelemetryAvailability Availability;
        internal TelemetryMetricKind Kind;
        private long _count;
        private double _sum, _min, _max, _last, _observed;
        private double? _baseline;
        internal void Add(double value, double observed)
        {
            _min = _count == 0 ? value : Math.Min(_min, value);
            _max = _count == 0 ? value : Math.Max(_max, value);
            _count++;
            _sum += value;
            _last = value;
            _observed = observed;
        }
        internal void Clear() { if (_count > 0) _baseline = _last; _count = 0; _sum = 0; }
        internal void Rebase() => _baseline = null;
        internal TelemetrySummary Snapshot() => new(_count == 0 ? Availability : TelemetryAvailability.Available,
            _count, _sum, _count == 0 ? null : _min, _count == 0 ? null : _max, _count == 0 ? null : _last)
        {
            Kind = Kind,
            LastObservedSeconds = _count == 0 ? null : _observed,
            WindowDelta = Kind == TelemetryMetricKind.LifetimeCounter && _count > 0 && _baseline is { } baseline ? _last - baseline : null
        };
    }
}

public sealed class TelemetrySource : IDisposable
{
    private readonly RuntimeProfiler _owner;
    internal Dictionary<string, RuntimeProfiler.Accumulator> Metrics { get; } = [];
    internal TelemetrySource(RuntimeProfiler owner, long id, string name, string backend)
        => (_owner, Id, Name, Backend) = (owner, id, name, backend);
    public long Id { get; }
    public string Name { get; }
    public string Backend { get; }
    public bool Define(string name, TelemetryAvailability availability = TelemetryAvailability.NotYetSampled,
        TelemetryMetricKind kind = TelemetryMetricKind.Sample)
        => _owner.Define(this, name, availability == TelemetryAvailability.Available ? TelemetryAvailability.NotYetSampled : availability, kind);
    internal void MarkTruncated(long generation) => _owner.MarkTruncated(generation);
    public long BeginSample() => _owner.Begin();
    public void Record(long generation, string metric, double value) => _owner.Record(this, generation, metric, value);
    public void Dispose() => _owner.Retire(this);
}