Program.cs

using System;
using System.IO;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Remora.Discord.API.Abstractions.Events;
using Remora.Discord.Gateway;
using Remora.Discord.Gateway.Extensions;
using Remora.Discord.Gateway.Responders;
using Remora.Discord.Gateway.Results;

namespace Scratchpad
{
    public class UnknownEventResponder : IResponder<IUnknownEvent>
    {
        private readonly ILogger<UnknownEventResponder> _log;

        public UnknownEventResponder(ILogger<UnknownEventResponder> log)
        {
            _log = log;
        }

        public async Task<EventResponseResult> RespondAsync
        (
            IUnknownEvent gatewayEvent,
            CancellationToken ct = new CancellationToken()
        )
        {
            using var jsonDocument = JsonDocument.Parse(gatewayEvent.Data);
            if (!jsonDocument.RootElement.TryGetProperty("t", out var eventTypeElement))
            {
                _log.LogWarning("Failed to find an event type on the given unknown event.");
                return EventResponseResult.FromSuccess();
            }

            if (!jsonDocument.RootElement.TryGetProperty("s", out var eventSequenceElement))
            {
                _log.LogWarning("Failed to find an event sequence on the given unknown event.");
                return EventResponseResult.FromSuccess();
            }

            var eventType = eventTypeElement.GetString();
            var sequenceNumber = eventSequenceElement.GetInt64();
            var logTime = $"{DateTime.UtcNow:u}";

            _log.LogInformation($"Received an event of type \"{eventType}\" at {logTime}.");

            var eventDirectory = Path.GetFullPath(eventType.ToUpperInvariant());
            if (!Directory.Exists(eventDirectory))
            {
                Directory.CreateDirectory(eventDirectory);
            }

            var filename = $"{logTime}.{sequenceNumber}.json";
            var filePath = Path.Combine(eventDirectory, filename);

            await using var file = File.OpenWrite(filePath);
            await using var jsonWriter = new Utf8JsonWriter(file, new JsonWriterOptions
            {
                Indented = true
            });

            jsonDocument.WriteTo(jsonWriter);

            return EventResponseResult.FromSuccess();
        }
    }

    public class Program
    {
        public static async Task Main(string[] args)
        {
            var cancellationSource = new CancellationTokenSource();

            var services = new ServiceCollection()
                .AddLogging
                (
                    c => c.AddConsole()
                )
                .AddDiscordGateway(() => "TOKEN_HERE")
                .BuildServiceProvider();

            var log = services.GetRequiredService<ILogger<Program>>();

            var gatewayClient = services.GetRequiredService<DiscordGatewayClient>();
            gatewayClient.SubscribeResponder<UnknownEventResponder>();

            var runResult = await gatewayClient.RunAsync(cancellationSource.Token);
            if (!runResult.IsSuccess)
            {
                log.LogError(runResult.Exception, runResult.ErrorReason);
            }
        }
    }
}