youys
/
Discord.Net
Not watched
1
0
Fork 0
Code
Releases 34 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
Browse Source

Use ilogger instead of old logger

pull/1765/head
Waterball 4 years ago
parent
6bf8ddea5f
commit
362a972213
7 changed files with 251 additions and 180 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +22
    -13
      src/Discord.Net.Rest/BaseDiscordClient.cs
  2. +54
    -37
      src/Discord.Net.WebSocket/Audio/AudioClient.cs
  3. +7
    -6
      src/Discord.Net.WebSocket/Audio/Streams/BufferedWriteStream.cs
  4. +10
    -9
      src/Discord.Net.WebSocket/ConnectionManager.cs
  5. +0
    -1
      src/Discord.Net.WebSocket/DiscordShardedClient.cs
  6. +137
    -103
      src/Discord.Net.WebSocket/DiscordSocketClient.cs
  7. +21
    -11
      src/Discord.Net.Webhook/DiscordWebhookClient.cs

+ 22
- 13
src/Discord.Net.Rest/BaseDiscordClient.cs View File

@@ -1,4 +1,5 @@
using Discord.Logging;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
@@ -10,20 +11,17 @@ namespace Discord.Rest
{
public abstract class BaseDiscordClient : IDiscordClient
{
public event Func<LogMessage, Task> Log { add { _logEvent.Add(value); } remove { _logEvent.Remove(value); } }
internal readonly AsyncEvent<Func<LogMessage, Task>> _logEvent = new AsyncEvent<Func<LogMessage, Task>>();

public event Func<Task> LoggedIn { add { _loggedInEvent.Add(value); } remove { _loggedInEvent.Remove(value); } }
private readonly AsyncEvent<Func<Task>> _loggedInEvent = new AsyncEvent<Func<Task>>();
public event Func<Task> LoggedOut { add { _loggedOutEvent.Add(value); } remove { _loggedOutEvent.Remove(value); } }
private readonly AsyncEvent<Func<Task>> _loggedOutEvent = new AsyncEvent<Func<Task>>();

internal readonly Logger _restLogger;
internal readonly ILogger _restLogger;
private readonly SemaphoreSlim _stateLock;
private bool _isFirstLogin, _isDisposed;

internal API.DiscordRestApiClient ApiClient { get; }
internal LogManager LogManager { get; }
internal ILoggerFactory LogManager { get; }
/// <summary>
/// Gets the login state of the client.
/// </summary>
@@ -39,21 +37,32 @@ namespace Discord.Rest
internal BaseDiscordClient(DiscordRestConfig config, API.DiscordRestApiClient client)
{
ApiClient = client;
LogManager = new LogManager(config.LogLevel);
LogManager.Message += async msg => await _logEvent.InvokeAsync(msg).ConfigureAwait(false);
LogManager = config.LoggerFactory;

if (LogManager == null)
{
LogManager = new DefaultLoggerFactory();
LogManager.AddProvider(new DefaultLoggerProvider());
}

_stateLock = new SemaphoreSlim(1, 1);
_restLogger = LogManager.CreateLogger("Rest");
_isFirstLogin = config.DisplayInitialLog;

ApiClient.RequestQueue.RateLimitTriggered += async (id, info, endpoint) =>
ApiClient.RequestQueue.RateLimitTriggered += (id, info, endpoint) =>
{
if (info == null)
await _restLogger.VerboseAsync($"Preemptive Rate limit triggered: {endpoint} {(id.IsHashBucket ? $"(Bucket: {id.BucketHash})" : "")}").ConfigureAwait(false);
_restLogger.LogTrace($"Preemptive Rate limit triggered: {endpoint} {(id.IsHashBucket ? $"(Bucket: {id.BucketHash})" : "")}");
else
await _restLogger.WarningAsync($"Rate limit triggered: {endpoint} {(id.IsHashBucket ? $"(Bucket: {id.BucketHash})" : "")}").ConfigureAwait(false);
_restLogger.LogTrace($"Rate limit triggered: {endpoint} {(id.IsHashBucket ? $"(Bucket: {id.BucketHash})" : "")}");

return Task.CompletedTask;
};
ApiClient.SentRequest += (method, endpoint, millis) =>
{
_restLogger.LogTrace($"{method} {endpoint}: {millis} ms");
return Task.CompletedTask;
};
ApiClient.SentRequest += async (method, endpoint, millis) => await _restLogger.VerboseAsync($"{method} {endpoint}: {millis} ms").ConfigureAwait(false);
}

public async Task LoginAsync(TokenType tokenType, string token, bool validateToken = true)
@@ -70,7 +79,7 @@ namespace Discord.Rest
if (_isFirstLogin)
{
_isFirstLogin = false;
await LogManager.WriteInitialLog().ConfigureAwait(false);
_restLogger.LogInformation($"Discord.Net v{DiscordConfig.Version} (API v{DiscordConfig.APIVersion})");
}

if (LoginState != LoginState.LoggedOut)
@@ -90,7 +99,7 @@ namespace Discord.Rest
catch (ArgumentException ex)
{
// log these ArgumentExceptions and allow for the client to attempt to log in anyways
await LogManager.WarningAsync("Discord", "A supplied token was invalid.", ex).ConfigureAwait(false);
_restLogger.LogWarning(ex, "A supplied token was invalid.");
}
}



+ 54
- 37
src/Discord.Net.WebSocket/Audio/AudioClient.cs View File

@@ -3,6 +3,7 @@ using Discord.Audio.Streams;
using Discord.Logging;
using Discord.Net.Converters;
using Discord.WebSocket;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
@@ -30,7 +31,7 @@ namespace Discord.Audio
}
}

private readonly Logger _audioLogger;
private readonly ILogger _audioLogger;
private readonly JsonSerializer _serializer;
private readonly ConnectionManager _connection;
private readonly SemaphoreSlim _stateLock;
@@ -64,8 +65,16 @@ namespace Discord.Audio
_audioLogger = Discord.LogManager.CreateLogger($"Audio #{clientId}");

ApiClient = new DiscordVoiceAPIClient(guild.Id, Discord.WebSocketProvider, Discord.UdpSocketProvider);
ApiClient.SentGatewayMessage += async opCode => await _audioLogger.DebugAsync($"Sent {opCode}").ConfigureAwait(false);
ApiClient.SentDiscovery += async () => await _audioLogger.DebugAsync("Sent Discovery").ConfigureAwait(false);
ApiClient.SentGatewayMessage += opCode =>
{
_audioLogger.LogDebug($"Sent {opCode}");
return Task.CompletedTask;
};
ApiClient.SentDiscovery += () =>
{
_audioLogger.LogDebug("Sent Discovery");
return Task.CompletedTask;
};
//ApiClient.SentData += async bytes => await _audioLogger.DebugAsync($"Sent {bytes} Bytes").ConfigureAwait(false);
ApiClient.ReceivedEvent += ProcessMessageAsync;
ApiClient.ReceivedPacket += ProcessPacketAsync;
@@ -83,12 +92,20 @@ namespace Discord.Audio
_serializer = new JsonSerializer { ContractResolver = new DiscordContractResolver() };
_serializer.Error += (s, e) =>
{
_audioLogger.WarningAsync(e.ErrorContext.Error).GetAwaiter().GetResult();
_audioLogger.LogWarning(e.ErrorContext.Error, e.ErrorContext.Error.Message);
e.ErrorContext.Handled = true;
};

LatencyUpdated += async (old, val) => await _audioLogger.DebugAsync($"Latency = {val} ms").ConfigureAwait(false);
UdpLatencyUpdated += async (old, val) => await _audioLogger.DebugAsync($"UDP Latency = {val} ms").ConfigureAwait(false);
LatencyUpdated += (old, val) =>
{
_audioLogger.LogDebug($"Latency = {val} ms");
return Task.CompletedTask;
};
UdpLatencyUpdated += (old, val) =>
{
_audioLogger.LogDebug($"UDP Latency = {val} ms");
return Task.CompletedTask;
};
}

internal async Task StartAsync(string url, ulong userId, string sessionId, string token)
@@ -112,10 +129,10 @@ namespace Discord.Audio

private async Task OnConnectingAsync()
{
await _audioLogger.DebugAsync("Connecting ApiClient").ConfigureAwait(false);
_audioLogger.LogDebug("Connecting ApiClient");
await ApiClient.ConnectAsync("wss://" + _url + "?v=" + DiscordConfig.VoiceAPIVersion).ConfigureAwait(false);
await _audioLogger.DebugAsync("Listening on port " + ApiClient.UdpPort).ConfigureAwait(false);
await _audioLogger.DebugAsync("Sending Identity").ConfigureAwait(false);
_audioLogger.LogDebug("Listening on port " + ApiClient.UdpPort);
_audioLogger.LogDebug("Sending Identity");
await ApiClient.SendIdentityAsync(_userId, _sessionId, _token).ConfigureAwait(false);

//Wait for READY
@@ -123,11 +140,11 @@ namespace Discord.Audio
}
private async Task OnDisconnectingAsync(Exception ex)
{
await _audioLogger.DebugAsync("Disconnecting ApiClient").ConfigureAwait(false);
_audioLogger.LogDebug("Disconnecting ApiClient");
await ApiClient.DisconnectAsync().ConfigureAwait(false);

//Wait for tasks to complete
await _audioLogger.DebugAsync("Waiting for heartbeater").ConfigureAwait(false);
_audioLogger.LogDebug("Waiting for heartbeater");
var heartbeatTask = _heartbeatTask;
if (heartbeatTask != null)
await heartbeatTask.ConfigureAwait(false);
@@ -142,7 +159,7 @@ namespace Discord.Audio

await ClearInputStreamsAsync().ConfigureAwait(false);

await _audioLogger.DebugAsync("Sending Voice State").ConfigureAwait(false);
_audioLogger.LogDebug("Sending Voice State");
await Discord.ApiClient.SendVoiceStateUpdateAsync(Guild.Id, null, false, false).ConfigureAwait(false);
}

@@ -224,7 +241,7 @@ namespace Discord.Audio
{
case VoiceOpCode.Ready:
{
await _audioLogger.DebugAsync("Received Ready").ConfigureAwait(false);
_audioLogger.LogDebug("Received Ready");
var data = (payload as JToken).ToObject<ReadyEvent>(_serializer);

_ssrc = data.SSRC;
@@ -241,7 +258,7 @@ namespace Discord.Audio
break;
case VoiceOpCode.SessionDescription:
{
await _audioLogger.DebugAsync("Received SessionDescription").ConfigureAwait(false);
_audioLogger.LogDebug("Received SessionDescription");
var data = (payload as JToken).ToObject<SessionDescriptionEvent>(_serializer);

if (data.Mode != DiscordVoiceAPIClient.Mode)
@@ -257,7 +274,7 @@ namespace Discord.Audio
break;
case VoiceOpCode.HeartbeatAck:
{
await _audioLogger.DebugAsync("Received HeartbeatAck").ConfigureAwait(false);
_audioLogger.LogDebug("Received HeartbeatAck");

if (_heartbeatTimes.TryDequeue(out long time))
{
@@ -271,7 +288,7 @@ namespace Discord.Audio
break;
case VoiceOpCode.Speaking:
{
await _audioLogger.DebugAsync("Received Speaking").ConfigureAwait(false);
_audioLogger.LogDebug("Received Speaking");

var data = (payload as JToken).ToObject<SpeakingEvent>(_serializer);
_ssrcMap[data.Ssrc] = data.UserId; //TODO: Memory Leak: SSRCs are never cleaned up
@@ -280,13 +297,13 @@ namespace Discord.Audio
}
break;
default:
await _audioLogger.WarningAsync($"Unknown OpCode ({opCode})").ConfigureAwait(false);
_audioLogger.LogWarning($"Unknown OpCode ({opCode})");
return;
}
}
catch (Exception ex)
{
await _audioLogger.ErrorAsync($"Error handling {opCode}", ex).ConfigureAwait(false);
_audioLogger.LogError($"Error handling {opCode}", ex);
return;
}
}
@@ -298,7 +315,7 @@ namespace Discord.Audio
{
if (packet.Length != 70)
{
await _audioLogger.DebugAsync("Malformed Packet").ConfigureAwait(false);
_audioLogger.LogDebug("Malformed Packet");
return;
}
string ip;
@@ -310,18 +327,18 @@ namespace Discord.Audio
}
catch (Exception ex)
{
await _audioLogger.DebugAsync("Malformed Packet", ex).ConfigureAwait(false);
_audioLogger.LogDebug("Malformed Packet", ex);
return;
}

await _audioLogger.DebugAsync("Received Discovery").ConfigureAwait(false);
_audioLogger.LogDebug("Received Discovery");
await ApiClient.SendSelectProtocol(ip, port).ConfigureAwait(false);
}
else if (_connection.State == ConnectionState.Connected)
{
if (packet.Length == 8)
{
await _audioLogger.DebugAsync("Received Keepalive").ConfigureAwait(false);
_audioLogger.LogDebug("Received Keepalive");

ulong value =
((ulong)packet[0] >> 0) |
@@ -350,17 +367,17 @@ namespace Discord.Audio
{
if (!RTPReadStream.TryReadSsrc(packet, 0, out var ssrc))
{
await _audioLogger.DebugAsync("Malformed Frame").ConfigureAwait(false);
_audioLogger.LogDebug("Malformed Frame");
return;
}
if (!_ssrcMap.TryGetValue(ssrc, out var userId))
{
await _audioLogger.DebugAsync($"Unknown SSRC {ssrc}").ConfigureAwait(false);
_audioLogger.LogDebug($"Unknown SSRC {ssrc}");
return;
}
if (!_streams.TryGetValue(userId, out var pair))
{
await _audioLogger.DebugAsync($"Unknown User {userId}").ConfigureAwait(false);
_audioLogger.LogDebug($"Unknown User {userId}");
return;
}
try
@@ -369,7 +386,7 @@ namespace Discord.Audio
}
catch (Exception ex)
{
await _audioLogger.DebugAsync("Malformed Frame", ex).ConfigureAwait(false);
_audioLogger.LogDebug(ex, "Malformed Frame");
return;
}
//await _audioLogger.DebugAsync($"Received {packet.Length} bytes from user {userId}").ConfigureAwait(false);
@@ -378,7 +395,7 @@ namespace Discord.Audio
}
catch (Exception ex)
{
await _audioLogger.WarningAsync("Failed to process UDP packet", ex).ConfigureAwait(false);
_audioLogger.LogWarning("Failed to process UDP packet", ex);
return;
}
}
@@ -388,7 +405,7 @@ namespace Discord.Audio
// TODO: Clean this up when Discord's session patch is live
try
{
await _audioLogger.DebugAsync("Heartbeat Started").ConfigureAwait(false);
_audioLogger.LogDebug("Heartbeat Started");
while (!cancelToken.IsCancellationRequested)
{
var now = Environment.TickCount;
@@ -408,27 +425,27 @@ namespace Discord.Audio
}
catch (Exception ex)
{
await _audioLogger.WarningAsync("Failed to send heartbeat", ex).ConfigureAwait(false);
_audioLogger.LogWarning("Failed to send heartbeat", ex);
}

await Task.Delay(intervalMillis, cancelToken).ConfigureAwait(false);
}
await _audioLogger.DebugAsync("Heartbeat Stopped").ConfigureAwait(false);
_audioLogger.LogDebug("Heartbeat Stopped");
}
catch (OperationCanceledException)
{
await _audioLogger.DebugAsync("Heartbeat Stopped").ConfigureAwait(false);
_audioLogger.LogDebug("Heartbeat Stopped");
}
catch (Exception ex)
{
await _audioLogger.ErrorAsync("Heartbeat Errored", ex).ConfigureAwait(false);
_audioLogger.LogError("Heartbeat Errored", ex);
}
}
private async Task RunKeepaliveAsync(int intervalMillis, CancellationToken cancelToken)
{
try
{
await _audioLogger.DebugAsync("Keepalive Started").ConfigureAwait(false);
_audioLogger.LogDebug("Keepalive Started");
while (!cancelToken.IsCancellationRequested)
{
var now = Environment.TickCount;
@@ -441,20 +458,20 @@ namespace Discord.Audio
}
catch (Exception ex)
{
await _audioLogger.WarningAsync("Failed to send keepalive", ex).ConfigureAwait(false);
_audioLogger.LogWarning("Failed to send keepalive", ex);
}

await Task.Delay(intervalMillis, cancelToken).ConfigureAwait(false);
}
await _audioLogger.DebugAsync("Keepalive Stopped").ConfigureAwait(false);
_audioLogger.LogDebug("Keepalive Stopped");
}
catch (OperationCanceledException)
{
await _audioLogger.DebugAsync("Keepalive Stopped").ConfigureAwait(false);
_audioLogger.LogDebug("Keepalive Stopped");
}
catch (Exception ex)
{
await _audioLogger.ErrorAsync("Keepalive Errored", ex).ConfigureAwait(false);
_audioLogger.LogError("Keepalive Errored", ex);
}
}



+ 7
- 6
src/Discord.Net.WebSocket/Audio/Streams/BufferedWriteStream.cs View File

@@ -1,4 +1,5 @@
using Discord.Logging;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Concurrent;
using System.Threading;
@@ -33,14 +34,14 @@ namespace Discord.Audio.Streams
private readonly ConcurrentQueue<Frame> _queuedFrames;
private readonly ConcurrentQueue<byte[]> _bufferPool;
private readonly SemaphoreSlim _queueLock;
private readonly Logger _logger;
private readonly ILogger _logger;
private readonly int _ticksPerFrame, _queueLength;
private bool _isPreloaded;
private int _silenceFrames;

public BufferedWriteStream(AudioStream next, IAudioClient client, int bufferMillis, CancellationToken cancelToken, int maxFrameSize = 1500)
: this(next, client as AudioClient, bufferMillis, cancelToken, null, maxFrameSize) { }
internal BufferedWriteStream(AudioStream next, AudioClient client, int bufferMillis, CancellationToken cancelToken, Logger logger, int maxFrameSize = 1500)
internal BufferedWriteStream(AudioStream next, AudioClient client, int bufferMillis, CancellationToken cancelToken, ILogger logger, int maxFrameSize = 1500)
{
//maxFrameSize = 1275 was too limiting at 128kbps,2ch,60ms
_next = next;
@@ -106,7 +107,7 @@ namespace Discord.Audio.Streams
timestamp += OpusEncoder.FrameSamplesPerChannel;
_silenceFrames = 0;
#if DEBUG
var _ = _logger?.DebugAsync($"Sent {frame.Bytes} bytes ({_queuedFrames.Count} frames buffered)");
_logger?.LogDebug($"Sent {frame.Bytes} bytes ({_queuedFrames.Count} frames buffered)");
#endif
}
else
@@ -125,7 +126,7 @@ namespace Discord.Audio.Streams
timestamp += OpusEncoder.FrameSamplesPerChannel;
}
#if DEBUG
var _ = _logger?.DebugAsync("Buffer underrun");
_logger?.LogDebug("Buffer underrun");
#endif
}
}
@@ -153,7 +154,7 @@ namespace Discord.Audio.Streams
if (!_bufferPool.TryDequeue(out byte[] buffer))
{
#if DEBUG
var _ = _logger?.DebugAsync("Buffer overflow"); //Should never happen because of the queueLock
_logger?.LogDebug("Buffer overflow"); //Should never happen because of the queueLock
#endif
#pragma warning disable IDISP016
writeCancelToken?.Dispose();
@@ -165,7 +166,7 @@ namespace Discord.Audio.Streams
if (!_isPreloaded && _queuedFrames.Count == _queueLength)
{
#if DEBUG
var _ = _logger?.DebugAsync("Preloaded");
_logger?.LogDebug("Preloaded");
#endif
_isPreloaded = true;
}


+ 10
- 9
src/Discord.Net.WebSocket/ConnectionManager.cs View File

@@ -3,6 +3,7 @@ using System;
using System.Threading;
using System.Threading.Tasks;
using Discord.Net;
using Microsoft.Extensions.Logging;

namespace Discord
{
@@ -14,7 +15,7 @@ namespace Discord
private readonly AsyncEvent<Func<Exception, bool, Task>> _disconnectedEvent = new AsyncEvent<Func<Exception, bool, Task>>();

private readonly SemaphoreSlim _stateLock;
private readonly Logger _logger;
private readonly ILogger _logger;
private readonly int _connectionTimeout;
private readonly Func<Task> _onConnecting;
private readonly Func<Exception, Task> _onDisconnecting;
@@ -28,7 +29,7 @@ namespace Discord
public ConnectionState State { get; private set; }
public CancellationToken CancelToken { get; private set; }

internal ConnectionManager(SemaphoreSlim stateLock, Logger logger, int connectionTimeout,
internal ConnectionManager(SemaphoreSlim stateLock, ILogger logger, int connectionTimeout,
Func<Task> onConnecting, Func<Exception, Task> onDisconnecting, Action<Func<Exception, Task>> clientDisconnectHandler)
{
_stateLock = stateLock;
@@ -85,12 +86,12 @@ namespace Discord
Error(ex); //In case this exception didn't come from another Error call
if (!reconnectCancelToken.IsCancellationRequested)
{
await _logger.WarningAsync(ex).ConfigureAwait(false);
_logger.LogWarning(ex, ex.Message);
await DisconnectAsync(ex, true).ConfigureAwait(false);
}
else
{
await _logger.ErrorAsync(ex).ConfigureAwait(false);
_logger.LogError(ex, ex.Message);
await DisconnectAsync(ex, false).ConfigureAwait(false);
}
}
@@ -124,7 +125,7 @@ namespace Discord

_connectionPromise = new TaskCompletionSource<bool>();
State = ConnectionState.Connecting;
await _logger.InfoAsync("Connecting").ConfigureAwait(false);
_logger.LogInformation("Connecting");

try
{
@@ -154,9 +155,9 @@ namespace Discord
throw innerEx;
}

await _logger.InfoAsync("Connected").ConfigureAwait(false);
_logger.LogInformation("Connected");
State = ConnectionState.Connected;
await _logger.DebugAsync("Raising Event").ConfigureAwait(false);
_logger.LogDebug("Raising Event");
await _connectedEvent.InvokeAsync().ConfigureAwait(false);
}
catch (Exception ex)
@@ -169,13 +170,13 @@ namespace Discord
{
if (State == ConnectionState.Disconnected) return;
State = ConnectionState.Disconnecting;
await _logger.InfoAsync("Disconnecting").ConfigureAwait(false);
_logger.LogInformation("Disconnecting");

await _onDisconnecting(ex).ConfigureAwait(false);

await _disconnectedEvent.InvokeAsync(ex, isReconnecting).ConfigureAwait(false);
State = ConnectionState.Disconnected;
await _logger.InfoAsync("Disconnected").ConfigureAwait(false);
_logger.LogInformation("Disconnected");
}

public async Task CompleteAsync()


+ 0
- 1
src/Discord.Net.WebSocket/DiscordShardedClient.cs View File

@@ -328,7 +328,6 @@ namespace Discord.WebSocket

private void RegisterEvents(DiscordSocketClient client, bool isPrimary)
{
client.Log += (msg) => _logEvent.InvokeAsync(msg);
client.LoggedOut += () =>
{
var state = LoginState;


+ 137
- 103
src/Discord.Net.WebSocket/DiscordSocketClient.cs View File

@@ -5,6 +5,7 @@ using Discord.Net.Converters;
using Discord.Net.Udp;
using Discord.Net.WebSockets;
using Discord.Rest;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
@@ -30,7 +31,7 @@ namespace Discord.WebSocket
private readonly DiscordSocketClient _parentClient;
private readonly ConcurrentQueue<long> _heartbeatTimes;
private readonly ConnectionManager _connection;
private readonly Logger _gatewayLogger;
private readonly ILogger _gatewayLogger;
private readonly SemaphoreSlim _stateLock;

private string _sessionId;
@@ -144,6 +145,7 @@ namespace Discord.WebSocket
_gatewayIntents = config.GatewayIntents;

_stateLock = new SemaphoreSlim(1, 1);

_gatewayLogger = LogManager.CreateLogger(ShardId == 0 && TotalShards == 1 ? "Gateway" : $"Shard #{ShardId}");
_connection = new ConnectionManager(_stateLock, _gatewayLogger, config.ConnectionTimeout,
OnConnectingAsync, OnDisconnectingAsync, x => ApiClient.Disconnected += x);
@@ -157,18 +159,42 @@ namespace Discord.WebSocket
_serializer = new JsonSerializer { ContractResolver = new DiscordContractResolver() };
_serializer.Error += (s, e) =>
{
_gatewayLogger.WarningAsync("Serializer Error", e.ErrorContext.Error).GetAwaiter().GetResult();
_gatewayLogger.LogWarning(e.ErrorContext.Error, "Serializer Error");
e.ErrorContext.Handled = true;
};

ApiClient.SentGatewayMessage += async opCode => await _gatewayLogger.DebugAsync($"Sent {opCode}").ConfigureAwait(false);
ApiClient.SentGatewayMessage += opCode =>
{
_gatewayLogger.LogDebug($"Sent {opCode}");
return Task.CompletedTask;
};
ApiClient.ReceivedGatewayEvent += ProcessMessageAsync;

LeftGuild += async g => await _gatewayLogger.InfoAsync($"Left {g.Name}").ConfigureAwait(false);
JoinedGuild += async g => await _gatewayLogger.InfoAsync($"Joined {g.Name}").ConfigureAwait(false);
GuildAvailable += async g => await _gatewayLogger.VerboseAsync($"Connected to {g.Name}").ConfigureAwait(false);
GuildUnavailable += async g => await _gatewayLogger.VerboseAsync($"Disconnected from {g.Name}").ConfigureAwait(false);
LatencyUpdated += async (old, val) => await _gatewayLogger.DebugAsync($"Latency = {val} ms").ConfigureAwait(false);
LeftGuild += g =>
{
_gatewayLogger.LogInformation($"Left {g.Name}");
return Task.CompletedTask;
};
JoinedGuild += g =>
{
_gatewayLogger.LogInformation($"Joined {g.Name}");
return Task.CompletedTask;
};
GuildAvailable += g =>
{
_gatewayLogger.LogTrace($"Connected to {g.Name}");
return Task.CompletedTask;
};
GuildUnavailable += g =>
{
_gatewayLogger.LogTrace($"Disconnected from {g.Name}");
return Task.CompletedTask;
};
LatencyUpdated += (old, val) =>
{
_gatewayLogger.LogDebug($"Latency = {val} ms");
return Task.CompletedTask;
};

GuildAvailable += g =>
{
@@ -232,17 +258,17 @@ namespace Discord.WebSocket
}
try
{
await _gatewayLogger.DebugAsync("Connecting ApiClient").ConfigureAwait(false);
_gatewayLogger.LogDebug("Connecting ApiClient");
await ApiClient.ConnectAsync().ConfigureAwait(false);

if (_sessionId != null)
{
await _gatewayLogger.DebugAsync("Resuming").ConfigureAwait(false);
_gatewayLogger.LogDebug("Resuming");
await ApiClient.SendResumeAsync(_sessionId, _lastSeq).ConfigureAwait(false);
}
else
{
await _gatewayLogger.DebugAsync("Identifying").ConfigureAwait(false);
_gatewayLogger.LogDebug("Identifying");
await ApiClient.SendIdentifyAsync(shardID: ShardId, totalShards: TotalShards, guildSubscriptions: _guildSubscriptions, gatewayIntents: _gatewayIntents, presence: BuildCurrentStatus()).ConfigureAwait(false);
}

@@ -258,11 +284,11 @@ namespace Discord.WebSocket
private async Task OnDisconnectingAsync(Exception ex)
{

await _gatewayLogger.DebugAsync("Disconnecting ApiClient").ConfigureAwait(false);
_gatewayLogger.LogDebug("Disconnecting ApiClient");
await ApiClient.DisconnectAsync(ex).ConfigureAwait(false);

//Wait for tasks to complete
await _gatewayLogger.DebugAsync("Waiting for heartbeater").ConfigureAwait(false);
_gatewayLogger.LogDebug("Waiting for heartbeater");
var heartbeatTask = _heartbeatTask;
if (heartbeatTask != null)
await heartbeatTask.ConfigureAwait(false);
@@ -271,18 +297,18 @@ namespace Discord.WebSocket
while (_heartbeatTimes.TryDequeue(out _)) { }
_lastMessageTime = 0;

await _gatewayLogger.DebugAsync("Waiting for guild downloader").ConfigureAwait(false);
_gatewayLogger.LogDebug("Waiting for guild downloader");
var guildDownloadTask = _guildDownloadTask;
if (guildDownloadTask != null)
await guildDownloadTask.ConfigureAwait(false);
_guildDownloadTask = null;

//Clear large guild queue
await _gatewayLogger.DebugAsync("Clearing large guild queue").ConfigureAwait(false);
_gatewayLogger.LogDebug("Clearing large guild queue");
while (_largeGuilds.TryDequeue(out _)) { }

//Raise virtual GUILD_UNAVAILABLEs
await _gatewayLogger.DebugAsync("Raising virtual GuildUnavailables").ConfigureAwait(false);
_gatewayLogger.LogDebug("Raising virtual GuildUnavailables");
foreach (var guild in State.Guilds)
{
if (guild.IsAvailable)
@@ -524,7 +550,7 @@ namespace Discord.WebSocket
{
case GatewayOpCode.Hello:
{
await _gatewayLogger.DebugAsync("Received Hello").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Hello");
var data = (payload as JToken).ToObject<HelloEvent>(_serializer);

_heartbeatTask = RunHeartbeatAsync(data.HeartbeatInterval, _connection.CancelToken);
@@ -532,14 +558,14 @@ namespace Discord.WebSocket
break;
case GatewayOpCode.Heartbeat:
{
await _gatewayLogger.DebugAsync("Received Heartbeat").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Heartbeat");

await ApiClient.SendHeartbeatAsync(_lastSeq).ConfigureAwait(false);
}
break;
case GatewayOpCode.HeartbeatAck:
{
await _gatewayLogger.DebugAsync("Received HeartbeatAck").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received HeartbeatAck");

if (_heartbeatTimes.TryDequeue(out long time))
{
@@ -553,8 +579,8 @@ namespace Discord.WebSocket
break;
case GatewayOpCode.InvalidSession:
{
await _gatewayLogger.DebugAsync("Received InvalidSession").ConfigureAwait(false);
await _gatewayLogger.WarningAsync("Failed to resume previous session").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received InvalidSession");
_gatewayLogger.LogWarning("Failed to resume previous session");

_sessionId = null;
_lastSeq = 0;
@@ -577,7 +603,7 @@ namespace Discord.WebSocket
break;
case GatewayOpCode.Reconnect:
{
await _gatewayLogger.DebugAsync("Received Reconnect").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Reconnect");
_connection.Error(new GatewayReconnectException("Server requested a reconnect"));
}
break;
@@ -589,7 +615,7 @@ namespace Discord.WebSocket
{
try
{
await _gatewayLogger.DebugAsync("Received Dispatch (READY)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (READY)");

var data = (payload as JToken).ToObject<ReadyEvent>(_serializer);
var state = new ClientState(data.Guilds.Length, data.PrivateChannels.Length);
@@ -637,14 +663,14 @@ namespace Discord.WebSocket
_ = DownloadUsersAsync(Guilds.Where(x => x.IsAvailable && !x.HasAllMembers));

await TimedInvokeAsync(_readyEvent, nameof(Ready)).ConfigureAwait(false);
await _gatewayLogger.InfoAsync("Ready").ConfigureAwait(false);
_gatewayLogger.LogInformation("Ready");
});
_ = _connection.CompleteAsync();
}
break;
case "RESUMED":
{
await _gatewayLogger.DebugAsync("Received Dispatch (RESUMED)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (RESUMED)");

_ = _connection.CompleteAsync();

@@ -655,7 +681,7 @@ namespace Discord.WebSocket
await GuildAvailableAsync(guild).ConfigureAwait(false);
}

await _gatewayLogger.InfoAsync("Resumed previous session").ConfigureAwait(false);
_gatewayLogger.LogInformation("Resumed previous session");
}
break;

@@ -668,7 +694,7 @@ namespace Discord.WebSocket
{
type = "GUILD_AVAILABLE";
_lastGuildAvailableTime = Environment.TickCount;
await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_AVAILABLE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (GUILD_AVAILABLE)");

var guild = State.GetGuild(data.Id);
if (guild != null)
@@ -693,7 +719,7 @@ namespace Discord.WebSocket
}
else
{
await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_CREATE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (GUILD_CREATE)");

var guild = AddGuild(data, State);
if (guild != null)
@@ -711,7 +737,7 @@ namespace Discord.WebSocket
break;
case "GUILD_UPDATE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_UPDATE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (GUILD_UPDATE)");

var data = (payload as JToken).ToObject<API.Guild>(_serializer);
var guild = State.GetGuild(data.Id);
@@ -730,7 +756,7 @@ namespace Discord.WebSocket
break;
case "GUILD_EMOJIS_UPDATE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_EMOJIS_UPDATE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (GUILD_EMOJIS_UPDATE)");

var data = (payload as JToken).ToObject<API.Gateway.GuildEmojiUpdateEvent>(_serializer);
var guild = State.GetGuild(data.GuildId);
@@ -749,7 +775,7 @@ namespace Discord.WebSocket
break;
case "GUILD_SYNC":
{
await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_SYNC)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (GUILD_SYNC)");
var data = (payload as JToken).ToObject<GuildSyncEvent>(_serializer);
var guild = State.GetGuild(data.Id);
if (guild != null)
@@ -775,7 +801,7 @@ namespace Discord.WebSocket
if (data.Unavailable == true)
{
type = "GUILD_UNAVAILABLE";
await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_UNAVAILABLE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (GUILD_UNAVAILABLE)");

var guild = State.GetGuild(data.Id);
if (guild != null)
@@ -791,7 +817,7 @@ namespace Discord.WebSocket
}
else
{
await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_DELETE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (GUILD_DELETE)");

var guild = RemoveGuild(data.Id);
if (guild != null)
@@ -812,7 +838,7 @@ namespace Discord.WebSocket
//Channels
case "CHANNEL_CREATE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (CHANNEL_CREATE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (CHANNEL_CREATE)");

var data = (payload as JToken).ToObject<API.Channel>(_serializer);
SocketChannel channel = null;
@@ -849,7 +875,7 @@ namespace Discord.WebSocket
break;
case "CHANNEL_UPDATE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (CHANNEL_UPDATE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (CHANNEL_UPDATE)");

var data = (payload as JToken).ToObject<API.Channel>(_serializer);
var channel = State.GetChannel(data.Id);
@@ -876,7 +902,7 @@ namespace Discord.WebSocket
break;
case "CHANNEL_DELETE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (CHANNEL_DELETE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (CHANNEL_DELETE)");

SocketChannel channel = null;
var data = (payload as JToken).ToObject<API.Channel>(_serializer);
@@ -915,7 +941,7 @@ namespace Discord.WebSocket
//Members
case "GUILD_MEMBER_ADD":
{
await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_MEMBER_ADD)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (GUILD_MEMBER_ADD)");

var data = (payload as JToken).ToObject<GuildMemberAddEvent>(_serializer);
var guild = State.GetGuild(data.GuildId);
@@ -941,7 +967,7 @@ namespace Discord.WebSocket
break;
case "GUILD_MEMBER_UPDATE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_MEMBER_UPDATE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (GUILD_MEMBER_UPDATE)");

var data = (payload as JToken).ToObject<GuildMemberUpdateEvent>(_serializer);
var guild = State.GetGuild(data.GuildId);
@@ -986,7 +1012,7 @@ namespace Discord.WebSocket
break;
case "GUILD_MEMBER_REMOVE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_MEMBER_REMOVE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (GUILD_MEMBER_REMOVE)");

var data = (payload as JToken).ToObject<GuildMemberRemoveEvent>(_serializer);
var guild = State.GetGuild(data.GuildId);
@@ -1021,7 +1047,7 @@ namespace Discord.WebSocket
break;
case "GUILD_MEMBERS_CHUNK":
{
await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_MEMBERS_CHUNK)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (GUILD_MEMBERS_CHUNK)");

var data = (payload as JToken).ToObject<GuildMembersChunkEvent>(_serializer);
var guild = State.GetGuild(data.GuildId);
@@ -1045,7 +1071,7 @@ namespace Discord.WebSocket
break;
case "CHANNEL_RECIPIENT_ADD":
{
await _gatewayLogger.DebugAsync("Received Dispatch (CHANNEL_RECIPIENT_ADD)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (CHANNEL_RECIPIENT_ADD)");

var data = (payload as JToken).ToObject<RecipientEvent>(_serializer);
if (State.GetChannel(data.ChannelId) is SocketGroupChannel channel)
@@ -1062,7 +1088,7 @@ namespace Discord.WebSocket
break;
case "CHANNEL_RECIPIENT_REMOVE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (CHANNEL_RECIPIENT_REMOVE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (CHANNEL_RECIPIENT_REMOVE)");

var data = (payload as JToken).ToObject<RecipientEvent>(_serializer);
if (State.GetChannel(data.ChannelId) is SocketGroupChannel channel)
@@ -1087,7 +1113,7 @@ namespace Discord.WebSocket
//Roles
case "GUILD_ROLE_CREATE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_ROLE_CREATE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (GUILD_ROLE_CREATE)");

var data = (payload as JToken).ToObject<GuildRoleCreateEvent>(_serializer);
var guild = State.GetGuild(data.GuildId);
@@ -1111,7 +1137,7 @@ namespace Discord.WebSocket
break;
case "GUILD_ROLE_UPDATE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_ROLE_UPDATE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (GUILD_ROLE_UPDATE)");

var data = (payload as JToken).ToObject<GuildRoleUpdateEvent>(_serializer);
var guild = State.GetGuild(data.GuildId);
@@ -1146,7 +1172,7 @@ namespace Discord.WebSocket
break;
case "GUILD_ROLE_DELETE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_ROLE_DELETE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (GUILD_ROLE_DELETE)");

var data = (payload as JToken).ToObject<GuildRoleDeleteEvent>(_serializer);
var guild = State.GetGuild(data.GuildId);
@@ -1180,7 +1206,7 @@ namespace Discord.WebSocket
//Bans
case "GUILD_BAN_ADD":
{
await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_BAN_ADD)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (GUILD_BAN_ADD)");

var data = (payload as JToken).ToObject<GuildBanEvent>(_serializer);
var guild = State.GetGuild(data.GuildId);
@@ -1206,7 +1232,7 @@ namespace Discord.WebSocket
break;
case "GUILD_BAN_REMOVE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_BAN_REMOVE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (GUILD_BAN_REMOVE)");

var data = (payload as JToken).ToObject<GuildBanEvent>(_serializer);
var guild = State.GetGuild(data.GuildId);
@@ -1234,7 +1260,7 @@ namespace Discord.WebSocket
//Messages
case "MESSAGE_CREATE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (MESSAGE_CREATE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (MESSAGE_CREATE)");

var data = (payload as JToken).ToObject<API.Message>(_serializer);
if (State.GetChannel(data.ChannelId) is ISocketMessageChannel channel)
@@ -1291,7 +1317,7 @@ namespace Discord.WebSocket
break;
case "MESSAGE_UPDATE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (MESSAGE_UPDATE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (MESSAGE_UPDATE)");

var data = (payload as JToken).ToObject<API.Message>(_serializer);
if (State.GetChannel(data.ChannelId) is ISocketMessageChannel channel)
@@ -1344,7 +1370,7 @@ namespace Discord.WebSocket
break;
case "MESSAGE_DELETE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (MESSAGE_DELETE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (MESSAGE_DELETE)");

var data = (payload as JToken).ToObject<API.Message>(_serializer);
if (State.GetChannel(data.ChannelId) is ISocketMessageChannel channel)
@@ -1371,7 +1397,7 @@ namespace Discord.WebSocket
break;
case "MESSAGE_REACTION_ADD":
{
await _gatewayLogger.DebugAsync("Received Dispatch (MESSAGE_REACTION_ADD)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (MESSAGE_REACTION_ADD)");

var data = (payload as JToken).ToObject<API.Gateway.Reaction>(_serializer);
if (State.GetChannel(data.ChannelId) is ISocketMessageChannel channel)
@@ -1404,7 +1430,7 @@ namespace Discord.WebSocket
break;
case "MESSAGE_REACTION_REMOVE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (MESSAGE_REACTION_REMOVE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (MESSAGE_REACTION_REMOVE)");

var data = (payload as JToken).ToObject<API.Gateway.Reaction>(_serializer);
if (State.GetChannel(data.ChannelId) is ISocketMessageChannel channel)
@@ -1437,7 +1463,7 @@ namespace Discord.WebSocket
break;
case "MESSAGE_REACTION_REMOVE_ALL":
{
await _gatewayLogger.DebugAsync("Received Dispatch (MESSAGE_REACTION_REMOVE_ALL)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (MESSAGE_REACTION_REMOVE_ALL)");

var data = (payload as JToken).ToObject<RemoveAllReactionsEvent>(_serializer);
if (State.GetChannel(data.ChannelId) is ISocketMessageChannel channel)
@@ -1459,7 +1485,7 @@ namespace Discord.WebSocket
break;
case "MESSAGE_REACTION_REMOVE_EMOJI":
{
await _gatewayLogger.DebugAsync("Received Dispatch (MESSAGE_REACTION_REMOVE_EMOJI)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (MESSAGE_REACTION_REMOVE_EMOJI)");

var data = (payload as JToken).ToObject<API.Gateway.RemoveAllReactionsForEmoteEvent>(_serializer);
if (State.GetChannel(data.ChannelId) is ISocketMessageChannel channel)
@@ -1487,11 +1513,11 @@ namespace Discord.WebSocket
break;
case "MESSAGE_DELETE_BULK":
{
await _gatewayLogger.DebugAsync("Received Dispatch (MESSAGE_DELETE_BULK)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (MESSAGE_DELETE_BULK)");

if (!ExclusiveBulkDelete.HasValue)
{
await _gatewayLogger.WarningAsync("A bulk delete event has been received, but the event handling behavior has not been set. " +
_gatewayLogger.LogWarning("A bulk delete event has been received, but the event handling behavior has not been set. " +
"To suppress this message, set the ExclusiveBulkDelete configuration property. " +
"This message will appear only once.");
ExclusiveBulkDelete = false;
@@ -1532,7 +1558,7 @@ namespace Discord.WebSocket
//Statuses
case "PRESENCE_UPDATE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (PRESENCE_UPDATE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (PRESENCE_UPDATE)");

var data = (payload as JToken).ToObject<API.Presence>(_serializer);

@@ -1591,7 +1617,7 @@ namespace Discord.WebSocket
break;
case "TYPING_START":
{
await _gatewayLogger.DebugAsync("Received Dispatch (TYPING_START)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (TYPING_START)");

var data = (payload as JToken).ToObject<TypingStartEvent>(_serializer);
if (State.GetChannel(data.ChannelId) is ISocketMessageChannel channel)
@@ -1618,7 +1644,7 @@ namespace Discord.WebSocket
//Users
case "USER_UPDATE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (USER_UPDATE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (USER_UPDATE)");

var data = (payload as JToken).ToObject<API.User>(_serializer);
if (data.Id == CurrentUser.Id)
@@ -1629,7 +1655,7 @@ namespace Discord.WebSocket
}
else
{
await _gatewayLogger.WarningAsync("Received USER_UPDATE for wrong user.").ConfigureAwait(false);
_gatewayLogger.LogWarning("Received USER_UPDATE for wrong user.");
return;
}
}
@@ -1638,7 +1664,7 @@ namespace Discord.WebSocket
//Voice
case "VOICE_STATE_UPDATE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (VOICE_STATE_UPDATE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (VOICE_STATE_UPDATE)");

var data = (payload as JToken).ToObject<API.VoiceState>(_serializer);
SocketUser user;
@@ -1712,7 +1738,7 @@ namespace Discord.WebSocket
break;
case "VOICE_SERVER_UPDATE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (VOICE_SERVER_UPDATE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (VOICE_SERVER_UPDATE)");

var data = (payload as JToken).ToObject<VoiceServerUpdateEvent>(_serializer);
var guild = State.GetGuild(data.GuildId);
@@ -1745,7 +1771,7 @@ namespace Discord.WebSocket
//Invites
case "INVITE_CREATE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (INVITE_CREATE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (INVITE_CREATE)");

var data = (payload as JToken).ToObject<API.Gateway.InviteCreateEvent>(_serializer);
if (State.GetChannel(data.ChannelId) is SocketGuildChannel channel)
@@ -1778,7 +1804,7 @@ namespace Discord.WebSocket
break;
case "INVITE_DELETE":
{
await _gatewayLogger.DebugAsync("Received Dispatch (INVITE_DELETE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Received Dispatch (INVITE_DELETE)");

var data = (payload as JToken).ToObject<API.Gateway.InviteDeleteEvent>(_serializer);
if (State.GetChannel(data.ChannelId) is SocketGuildChannel channel)
@@ -1802,41 +1828,41 @@ namespace Discord.WebSocket

//Ignored (User only)
case "CHANNEL_PINS_ACK":
await _gatewayLogger.DebugAsync("Ignored Dispatch (CHANNEL_PINS_ACK)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Ignored Dispatch (CHANNEL_PINS_ACK)");
break;
case "CHANNEL_PINS_UPDATE":
await _gatewayLogger.DebugAsync("Ignored Dispatch (CHANNEL_PINS_UPDATE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Ignored Dispatch (CHANNEL_PINS_UPDATE)");
break;
case "GUILD_INTEGRATIONS_UPDATE":
await _gatewayLogger.DebugAsync("Ignored Dispatch (GUILD_INTEGRATIONS_UPDATE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Ignored Dispatch (GUILD_INTEGRATIONS_UPDATE)");
break;
case "MESSAGE_ACK":
await _gatewayLogger.DebugAsync("Ignored Dispatch (MESSAGE_ACK)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Ignored Dispatch (MESSAGE_ACK)");
break;
case "PRESENCES_REPLACE":
await _gatewayLogger.DebugAsync("Ignored Dispatch (PRESENCES_REPLACE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Ignored Dispatch (PRESENCES_REPLACE)");
break;
case "USER_SETTINGS_UPDATE":
await _gatewayLogger.DebugAsync("Ignored Dispatch (USER_SETTINGS_UPDATE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Ignored Dispatch (USER_SETTINGS_UPDATE)");
break;
case "WEBHOOKS_UPDATE":
await _gatewayLogger.DebugAsync("Ignored Dispatch (WEBHOOKS_UPDATE)").ConfigureAwait(false);
_gatewayLogger.LogDebug("Ignored Dispatch (WEBHOOKS_UPDATE)");
break;

//Others
default:
await _gatewayLogger.WarningAsync($"Unknown Dispatch ({type})").ConfigureAwait(false);
_gatewayLogger.LogWarning($"Unknown Dispatch ({type})");
break;
}
break;
default:
await _gatewayLogger.WarningAsync($"Unknown OpCode ({opCode})").ConfigureAwait(false);
_gatewayLogger.LogWarning($"Unknown OpCode ({opCode})");
break;
}
}
catch (Exception ex)
{
await _gatewayLogger.ErrorAsync($"Error handling {opCode}{(type != null ? $" ({type})" : "")}", ex).ConfigureAwait(false);
_gatewayLogger.LogError(ex, $"Error handling {opCode}{(type != null ? $" ({type})" : "")}");
}
}

@@ -1844,7 +1870,7 @@ namespace Discord.WebSocket
{
try
{
await _gatewayLogger.DebugAsync("Heartbeat Started").ConfigureAwait(false);
_gatewayLogger.LogDebug("Heartbeat Started");
while (!cancelToken.IsCancellationRequested)
{
int now = Environment.TickCount;
@@ -1866,20 +1892,20 @@ namespace Discord.WebSocket
}
catch (Exception ex)
{
await _gatewayLogger.WarningAsync("Heartbeat Errored", ex).ConfigureAwait(false);
_gatewayLogger.LogWarning("Heartbeat Errored", ex);
}

await Task.Delay(intervalMillis, cancelToken).ConfigureAwait(false);
}
await _gatewayLogger.DebugAsync("Heartbeat Stopped").ConfigureAwait(false);
_gatewayLogger.LogDebug("Heartbeat Stopped");
}
catch (OperationCanceledException)
{
await _gatewayLogger.DebugAsync("Heartbeat Stopped").ConfigureAwait(false);
_gatewayLogger.LogDebug("Heartbeat Stopped");
}
catch (Exception ex)
{
await _gatewayLogger.ErrorAsync("Heartbeat Errored", ex).ConfigureAwait(false);
_gatewayLogger.LogError(ex, "Heartbeat Errored");
}
}
/*public async Task WaitForGuildsAsync()
@@ -1888,23 +1914,23 @@ namespace Discord.WebSocket
if (downloadTask != null)
await _guildDownloadTask.ConfigureAwait(false);
}*/
private async Task WaitForGuildsAsync(CancellationToken cancelToken, Logger logger)
private async Task WaitForGuildsAsync(CancellationToken cancelToken, ILogger logger)
{
//Wait for GUILD_AVAILABLEs
try
{
await logger.DebugAsync("GuildDownloader Started").ConfigureAwait(false);
logger.LogDebug("GuildDownloader Started");
while ((_unavailableGuildCount != 0) && (Environment.TickCount - _lastGuildAvailableTime < BaseConfig.MaxWaitBetweenGuildAvailablesBeforeReady))
await Task.Delay(500, cancelToken).ConfigureAwait(false);
await logger.DebugAsync("GuildDownloader Stopped").ConfigureAwait(false);
logger.LogDebug("GuildDownloader Stopped");
}
catch (OperationCanceledException)
{
await logger.DebugAsync("GuildDownloader Stopped").ConfigureAwait(false);
logger.LogDebug("GuildDownloader Stopped");
}
catch (Exception ex)
{
await logger.ErrorAsync("GuildDownloader Errored", ex).ConfigureAwait(false);
logger.LogError(ex, "GuildDownloader Errored");
}
}
private async Task SyncGuildsAsync()
@@ -2034,40 +2060,45 @@ namespace Discord.WebSocket
var handlersTask = action();
if (await Task.WhenAny(timeoutTask, handlersTask).ConfigureAwait(false) == timeoutTask)
{
await _gatewayLogger.WarningAsync($"A {name} handler is blocking the gateway task.").ConfigureAwait(false);
_gatewayLogger.LogWarning($"A {name} handler is blocking the gateway task.");
}
await handlersTask.ConfigureAwait(false); //Ensure the handler completes
}
catch (Exception ex)
{
await _gatewayLogger.WarningAsync($"A {name} handler has thrown an unhandled exception.", ex).ConfigureAwait(false);
_gatewayLogger.LogWarning(ex, $"A {name} handler has thrown an unhandled exception.");
}
}

private async Task UnknownGlobalUserAsync(string evnt, ulong userId)
private Task UnknownGlobalUserAsync(string evnt, ulong userId)
{
string details = $"{evnt} User={userId}";
await _gatewayLogger.WarningAsync($"Unknown User ({details}).").ConfigureAwait(false);
_gatewayLogger.LogWarning($"Unknown User ({details}).");
return Task.CompletedTask;
}
private async Task UnknownChannelUserAsync(string evnt, ulong userId, ulong channelId)
private Task UnknownChannelUserAsync(string evnt, ulong userId, ulong channelId)
{
string details = $"{evnt} User={userId} Channel={channelId}";
await _gatewayLogger.WarningAsync($"Unknown User ({details}).").ConfigureAwait(false);
_gatewayLogger.LogWarning($"Unknown User ({details}).");
return Task.CompletedTask;
}
private async Task UnknownGuildUserAsync(string evnt, ulong userId, ulong guildId)
private Task UnknownGuildUserAsync(string evnt, ulong userId, ulong guildId)
{
string details = $"{evnt} User={userId} Guild={guildId}";
await _gatewayLogger.WarningAsync($"Unknown User ({details}).").ConfigureAwait(false);
_gatewayLogger.LogWarning($"Unknown User ({details}).");
return Task.CompletedTask;
}
private async Task IncompleteGuildUserAsync(string evnt, ulong userId, ulong guildId)
private Task IncompleteGuildUserAsync(string evnt, ulong userId, ulong guildId)
{
string details = $"{evnt} User={userId} Guild={guildId}";
await _gatewayLogger.DebugAsync($"User has not been downloaded ({details}).").ConfigureAwait(false);
_gatewayLogger.LogDebug($"User has not been downloaded ({details}).");
return Task.CompletedTask;
}
private async Task UnknownChannelAsync(string evnt, ulong channelId)
private Task UnknownChannelAsync(string evnt, ulong channelId)
{
string details = $"{evnt} Channel={channelId}";
await _gatewayLogger.WarningAsync($"Unknown Channel ({details}).").ConfigureAwait(false);
_gatewayLogger.LogWarning($"Unknown Channel ({details}).");
return Task.CompletedTask;
}
private async Task UnknownChannelAsync(string evnt, ulong channelId, ulong guildId)
{
@@ -2077,22 +2108,25 @@ namespace Discord.WebSocket
return;
}
string details = $"{evnt} Channel={channelId} Guild={guildId}";
await _gatewayLogger.WarningAsync($"Unknown Channel ({details}).").ConfigureAwait(false);
_gatewayLogger.LogWarning($"Unknown Channel ({details}).");
}
private async Task UnknownRoleAsync(string evnt, ulong roleId, ulong guildId)
private Task UnknownRoleAsync(string evnt, ulong roleId, ulong guildId)
{
string details = $"{evnt} Role={roleId} Guild={guildId}";
await _gatewayLogger.WarningAsync($"Unknown Role ({details}).").ConfigureAwait(false);
_gatewayLogger.LogWarning($"Unknown Role ({details}).");
return Task.CompletedTask;
}
private async Task UnknownGuildAsync(string evnt, ulong guildId)
private Task UnknownGuildAsync(string evnt, ulong guildId)
{
string details = $"{evnt} Guild={guildId}";
await _gatewayLogger.WarningAsync($"Unknown Guild ({details}).").ConfigureAwait(false);
_gatewayLogger.LogWarning($"Unknown Guild ({details}).");
return Task.CompletedTask;
}
private async Task UnsyncedGuildAsync(string evnt, ulong guildId)
private Task UnsyncedGuildAsync(string evnt, ulong guildId)
{
string details = $"{evnt} Guild={guildId}";
await _gatewayLogger.DebugAsync($"Unsynced Guild ({details}).").ConfigureAwait(false);
_gatewayLogger.LogDebug($"Unsynced Guild ({details}).");
return Task.CompletedTask;
}

internal int GetAudioId() => _nextAudioId++;


+ 21
- 11
src/Discord.Net.Webhook/DiscordWebhookClient.cs View File

@@ -6,21 +6,19 @@ using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Discord.Logging;
using Discord.Rest;
using Microsoft.Extensions.Logging;

namespace Discord.Webhook
{
/// <summary> A client responsible for connecting as a Webhook. </summary>
public class DiscordWebhookClient : IDisposable
{
public event Func<LogMessage, Task> Log { add { _logEvent.Add(value); } remove { _logEvent.Remove(value); } }
internal readonly AsyncEvent<Func<LogMessage, Task>> _logEvent = new AsyncEvent<Func<LogMessage, Task>>();

private readonly ulong _webhookId;
internal IWebhook Webhook;
internal readonly Logger _restLogger;
internal readonly ILogger _restLogger;
internal API.DiscordRestApiClient ApiClient { get; }
internal LogManager LogManager { get; }
internal ILoggerFactory LogManager { get; }

/// <summary> Creates a new Webhook Discord client. </summary>
public DiscordWebhookClient(IWebhook webhook)
@@ -69,19 +67,31 @@ namespace Discord.Webhook
private DiscordWebhookClient(DiscordRestConfig config)
{
ApiClient = CreateApiClient(config);
LogManager = new LogManager(config.LogLevel);
LogManager.Message += async msg => await _logEvent.InvokeAsync(msg).ConfigureAwait(false);
LogManager = config.LoggerFactory;

if (LogManager == null)
{
LogManager = new DefaultLoggerFactory();
LogManager.AddProvider(new DefaultLoggerProvider());
}

_restLogger = LogManager.CreateLogger("Rest");

ApiClient.RequestQueue.RateLimitTriggered += async (id, info, endpoint) =>
ApiClient.RequestQueue.RateLimitTriggered += (id, info, endpoint) =>
{
if (info == null)
await _restLogger.VerboseAsync($"Preemptive Rate limit triggered: {endpoint} {(id.IsHashBucket ? $"(Bucket: {id.BucketHash})" : "")}").ConfigureAwait(false);
_restLogger.LogTrace($"Preemptive Rate limit triggered: {endpoint} {(id.IsHashBucket ? $"(Bucket: {id.BucketHash})" : "")}");
else
await _restLogger.WarningAsync($"Rate limit triggered: {endpoint} {(id.IsHashBucket ? $"(Bucket: {id.BucketHash})" : "")}").ConfigureAwait(false);
_restLogger.LogWarning($"Rate limit triggered: {endpoint} {(id.IsHashBucket ? $"(Bucket: {id.BucketHash})" : "")}");

return Task.CompletedTask;
};
ApiClient.SentRequest += (method, endpoint, millis) =>
{
_restLogger.LogTrace($"{method} {endpoint}: {millis} ms");
return Task.CompletedTask;
};
ApiClient.SentRequest += async (method, endpoint, millis) => await _restLogger.VerboseAsync($"{method} {endpoint}: {millis} ms").ConfigureAwait(false);
}
private static API.DiscordRestApiClient CreateApiClient(DiscordRestConfig config)
=> new API.DiscordRestApiClient(config.RestClientProvider, DiscordRestConfig.UserAgent);


Write Preview
Loading…
Cancel
Save