CryptoExchange.Net/CryptoExchange.Net/Logging/Extensions/TrackerLoggingExtensions.cs

using System;
using CryptoExchange.Net.Objects;
using Microsoft.Extensions.Logging;

namespace CryptoExchange.Net.Logging.Extensions;

#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member

public static class TrackerLoggingExtensions
{
    private static readonly Action<ILogger, string, SyncStatus, SyncStatus, Exception?> _klineTrackerStatusChanged;
    private static readonly Action<ILogger, string, Exception?> _klineTrackerStarting;
    private static readonly Action<ILogger, string, string, Exception?> _klineTrackerStartFailed;
    private static readonly Action<ILogger, string, Exception?> _klineTrackerStarted;
    private static readonly Action<ILogger, string, Exception?> _klineTrackerStopping;
    private static readonly Action<ILogger, string, Exception?> _klineTrackerStopped;
    private static readonly Action<ILogger, string, DateTime, Exception?> _klineTrackerInitialDataSet;
    private static readonly Action<ILogger, string, DateTime, Exception?> _klineTrackerKlineUpdated;
    private static readonly Action<ILogger, string, DateTime, Exception?> _klineTrackerKlineAdded;
    private static readonly Action<ILogger, string, Exception?> _klineTrackerConnectionLost;
    private static readonly Action<ILogger, string, Exception?> _klineTrackerConnectionClosed;
    private static readonly Action<ILogger, string, Exception?> _klineTrackerConnectionRestored;

    private static readonly Action<ILogger, string, SyncStatus, SyncStatus, Exception?> _tradeTrackerStatusChanged;
    private static readonly Action<ILogger, string, Exception?> _tradeTrackerStarting;
    private static readonly Action<ILogger, string, string, Exception?> _tradeTrackerStartFailed;
    private static readonly Action<ILogger, string, Exception?> _tradeTrackerStarted;
    private static readonly Action<ILogger, string, Exception?> _tradeTrackerStopping;
    private static readonly Action<ILogger, string, Exception?> _tradeTrackerStopped;
    private static readonly Action<ILogger, string, int, long, Exception?> _tradeTrackerInitialDataSet;
    private static readonly Action<ILogger, string, long, Exception?> _tradeTrackerPreSnapshotSkip;
    private static readonly Action<ILogger, string, long, Exception?> _tradeTrackerPreSnapshotApplied;
    private static readonly Action<ILogger, string, long, Exception?> _tradeTrackerTradeAdded;
    private static readonly Action<ILogger, string, Exception?> _tradeTrackerConnectionLost;
    private static readonly Action<ILogger, string, Exception?> _tradeTrackerConnectionClosed;
    private static readonly Action<ILogger, string, Exception?> _tradeTrackerConnectionRestored;

    static TrackerLoggingExtensions()
    {
        _klineTrackerStatusChanged = LoggerMessage.Define<string, SyncStatus, SyncStatus>(
            LogLevel.Debug,
            new EventId(6001, "KlineTrackerStatusChanged"),
            "Kline tracker for {Symbol} status changed: {OldStatus} => {NewStatus}");

        _klineTrackerStarting = LoggerMessage.Define<string>(
            LogLevel.Debug,
            new EventId(6002, "KlineTrackerStarting"),
            "Kline tracker for {Symbol} starting");

        _klineTrackerStartFailed = LoggerMessage.Define<string, string>(
            LogLevel.Warning,
            new EventId(6003, "KlineTrackerStartFailed"),
            "Kline tracker for {Symbol} failed to start: {Error}");

        _klineTrackerStarted = LoggerMessage.Define<string>(
            LogLevel.Information,
            new EventId(6004, "KlineTrackerStarted"),
            "Kline tracker for {Symbol} started");

        _klineTrackerStopping = LoggerMessage.Define<string>(
            LogLevel.Debug,
            new EventId(6005, "KlineTrackerStopping"),
            "Kline tracker for {Symbol} stopping");

        _klineTrackerStopped = LoggerMessage.Define<string>(
            LogLevel.Information,
            new EventId(6006, "KlineTrackerStopped"),
            "Kline tracker for {Symbol} stopped");

        _klineTrackerInitialDataSet = LoggerMessage.Define<string, DateTime>(
            LogLevel.Debug,
            new EventId(6007, "KlineTrackerInitialDataSet"),
            "Kline tracker for {Symbol} initial data set, last timestamp: {LastTime}");

        _klineTrackerKlineUpdated = LoggerMessage.Define<string, DateTime>(
            LogLevel.Trace,
            new EventId(6008, "KlineTrackerKlineUpdated"),
            "Kline tracker for {Symbol} kline updated for open time: {LastTime}");

        _klineTrackerKlineAdded = LoggerMessage.Define<string, DateTime>(
            LogLevel.Trace,
            new EventId(6009, "KlineTrackerKlineAdded"),
            "Kline tracker for {Symbol} new kline for open time: {LastTime}");

        _klineTrackerConnectionLost = LoggerMessage.Define<string>(
            LogLevel.Warning,
            new EventId(6010, "KlineTrackerConnectionLost"),
            "Kline tracker for {Symbol} connection lost");

        _klineTrackerConnectionClosed = LoggerMessage.Define<string>(
            LogLevel.Warning,
            new EventId(6011, "KlineTrackerConnectionClosed"),
            "Kline tracker for {Symbol} disconnected");

        _klineTrackerConnectionRestored = LoggerMessage.Define<string>(
            LogLevel.Information,
            new EventId(6012, "KlineTrackerConnectionRestored"),
            "Kline tracker for {Symbol} successfully resynchronized");

        _tradeTrackerStatusChanged = LoggerMessage.Define<string, SyncStatus, SyncStatus>(
            LogLevel.Debug,
            new EventId(6013, "KlineTrackerStatusChanged"),
            "Trade tracker for {Symbol} status changed: {OldStatus} => {NewStatus}");

        _tradeTrackerStarting = LoggerMessage.Define<string>(
            LogLevel.Debug,
            new EventId(6014, "KlineTrackerStarting"),
            "Trade tracker for {Symbol} starting");

        _tradeTrackerStartFailed = LoggerMessage.Define<string, string>(
            LogLevel.Warning,
            new EventId(6015, "KlineTrackerStartFailed"),
            "Trade tracker for {Symbol} failed to start: {Error}");

        _tradeTrackerStarted = LoggerMessage.Define<string>(
            LogLevel.Information,
            new EventId(6016, "KlineTrackerStarted"),
            "Trade tracker for {Symbol} started");

        _tradeTrackerStopping = LoggerMessage.Define<string>(
            LogLevel.Debug,
            new EventId(6017, "KlineTrackerStopping"),
            "Trade tracker for {Symbol} stopping");

        _tradeTrackerStopped = LoggerMessage.Define<string>(
            LogLevel.Information,
            new EventId(6018, "KlineTrackerStopped"),
            "Trade tracker for {Symbol} stopped");

        _tradeTrackerInitialDataSet = LoggerMessage.Define<string, int, long>(
            LogLevel.Debug,
            new EventId(6019, "TradeTrackerInitialDataSet"),
            "Trade tracker for {Symbol} snapshot set, Count: {Count}, Last id: {LastId}");

        _tradeTrackerPreSnapshotSkip = LoggerMessage.Define<string, long>(
            LogLevel.Trace,
            new EventId(6020, "TradeTrackerPreSnapshotSkip"),
            "Trade tracker for {Symbol} skipping {Id}, already in snapshot");

        _tradeTrackerPreSnapshotApplied = LoggerMessage.Define<string, long>(
            LogLevel.Trace,
            new EventId(6021, "TradeTrackerPreSnapshotApplied"),
            "Trade tracker for {Symbol} adding {Id} from pre-snapshot");

        _tradeTrackerTradeAdded = LoggerMessage.Define<string, long>(
            LogLevel.Trace,
            new EventId(6022, "TradeTrackerTradeAdded"),
            "Trade tracker for {Symbol} adding trade {Id}");

        _tradeTrackerConnectionLost = LoggerMessage.Define<string>(
            LogLevel.Warning,
            new EventId(6023, "TradeTrackerConnectionLost"),
            "Trade tracker for {Symbol} connection lost");

        _tradeTrackerConnectionClosed = LoggerMessage.Define<string>(
            LogLevel.Warning,
            new EventId(6024, "TradeTrackerConnectionClosed"),
            "Trade tracker for {Symbol} disconnected");

        _tradeTrackerConnectionRestored = LoggerMessage.Define<string>(
            LogLevel.Information,
            new EventId(6025, "TradeTrackerConnectionRestored"),
            "Trade tracker for {Symbol} successfully resynchronized");
    }

    public static void KlineTrackerStatusChanged(this ILogger logger, string symbol, SyncStatus oldStatus, SyncStatus newStatus)
    {
        _klineTrackerStatusChanged(logger, symbol, oldStatus, newStatus, null);
    }

    public static void KlineTrackerStarting(this ILogger logger, string symbol)
    {
        _klineTrackerStarting(logger, symbol, null);
    }

    public static void KlineTrackerStartFailed(this ILogger logger, string symbol, string error, Exception? exception)
    {
        _klineTrackerStartFailed(logger, symbol, error, exception);
    }

    public static void KlineTrackerStarted(this ILogger logger, string symbol)
    {
        _klineTrackerStarted(logger, symbol, null);
    }

    public static void KlineTrackerStopping(this ILogger logger, string symbol)
    {
        _klineTrackerStopping(logger, symbol, null);
    }

    public static void KlineTrackerStopped(this ILogger logger, string symbol)
    {
        _klineTrackerStopped(logger, symbol, null);
    }

    public static void KlineTrackerInitialDataSet(this ILogger logger, string symbol, DateTime lastTime)
    {
        _klineTrackerInitialDataSet(logger, symbol, lastTime, null);
    }

    public static void KlineTrackerKlineUpdated(this ILogger logger, string symbol, DateTime lastTime)
    {
        _klineTrackerKlineUpdated(logger, symbol, lastTime, null);
    }

    public static void KlineTrackerKlineAdded(this ILogger logger, string symbol, DateTime lastTime)
    {
        _klineTrackerKlineAdded(logger, symbol, lastTime, null);
    }

    public static void KlineTrackerConnectionLost(this ILogger logger, string symbol)
    {
        _klineTrackerConnectionLost(logger, symbol, null);
    }

    public static void KlineTrackerConnectionClosed(this ILogger logger, string symbol)
    {
        _klineTrackerConnectionClosed(logger, symbol, null);
    }

    public static void KlineTrackerConnectionRestored(this ILogger logger, string symbol)
    {
        _klineTrackerConnectionRestored(logger, symbol, null);
    }

    public static void TradeTrackerStatusChanged(this ILogger logger, string symbol, SyncStatus oldStatus, SyncStatus newStatus)
    {
        _tradeTrackerStatusChanged(logger, symbol, oldStatus, newStatus, null);
    }

    public static void TradeTrackerStarting(this ILogger logger, string symbol)
    {
        _tradeTrackerStarting(logger, symbol, null);
    }

    public static void TradeTrackerStartFailed(this ILogger logger, string symbol, string error, Exception? ex)
    {
        _tradeTrackerStartFailed(logger, symbol, error, ex);
    }

    public static void TradeTrackerStarted(this ILogger logger, string symbol)
    {
        _tradeTrackerStarted(logger, symbol, null);
    }

    public static void TradeTrackerStopping(this ILogger logger, string symbol)
    {
        _tradeTrackerStopping(logger, symbol, null);
    }

    public static void TradeTrackerStopped(this ILogger logger, string symbol)
    {
        _tradeTrackerStopped(logger, symbol, null);
    }

    public static void TradeTrackerInitialDataSet(this ILogger logger, string symbol, int count, long lastId)
    {
        _tradeTrackerInitialDataSet(logger, symbol, count, lastId, null);
    }

    public static void TradeTrackerPreSnapshotSkip(this ILogger logger, string symbol, long lastId)
    {
        _tradeTrackerPreSnapshotSkip(logger, symbol, lastId, null);
    }

    public static void TradeTrackerPreSnapshotApplied(this ILogger logger, string symbol, long lastId)
    {
        _tradeTrackerPreSnapshotApplied(logger, symbol, lastId, null);
    }

    public static void TradeTrackerTradeAdded(this ILogger logger, string symbol, long lastId)
    {
        _tradeTrackerTradeAdded(logger, symbol, lastId, null);
    }

    public static void TradeTrackerConnectionLost(this ILogger logger, string symbol)
    {
        _tradeTrackerConnectionLost(logger, symbol, null);
    }

    public static void TradeTrackerConnectionClosed(this ILogger logger, string symbol)
    {
        _tradeTrackerConnectionClosed(logger, symbol, null);
    }

    public static void TradeTrackerConnectionRestored(this ILogger logger, string symbol)
    {
        _tradeTrackerConnectionRestored(logger, symbol, null);
    }
}