Beispiel #1
0
        private async Task HandleMessageReceived(IMessage message)
        {
            Log.LogDebug("Handling message received event for message #{MessageId}.", message.Id);

            if (!message.Content.StartsWith('!') &&
                message.Channel is IGuildChannel channel &&
                message.Author is IGuildUser author &&
                author.Guild is IGuild guild &&
                !author.IsBot && !author.IsWebhook)
            {
                using (_stats.StartTimer("message_processing_ms"))
                {
                    await SelfExecuteRequest <IMessageRepository>(
                        async messages =>
                    {
                        Log.LogInformation("Logging message #{MessageId} to the database.", message.Id);

                        var creationData = new MessageCreationData
                        {
                            Id        = message.Id,
                            GuildId   = guild.Id,
                            ChannelId = channel.Id,
                            AuthorId  = author.Id,
                            Timestamp = message.Timestamp
                        };

                        Log.LogDebug("Entity for message #{MessageId}: {@Message}", message.Id, creationData);

                        using (var transaction = await messages.BeginMaintainTransactionAsync())
                        {
                            try
                            {
                                await messages.CreateAsync(creationData);
                            }
                            catch (Exception ex)
                            {
                                Log.LogError(ex, "An unexpected error occurred when attempting to log message #{MessageId}.", message.Id);
                            }
                            transaction.Commit();
                        }
                    });
                }
            }
        }
Beispiel #2
0
        public async Task HandleNotificationAsync(IMessageCreate notification, CancellationToken ct)
        {
            var isThreadChannel = await _threadService.IsThreadChannelAsync(notification.ChannelID, ct);

            if (!isThreadChannel)
            {
                return;
            }

            using var statsScope = _dogStatsd.StartTimer("message_processing_ms");

            var message = notification;
            var channel = notification.ChannelID;
            var guild   = notification.GuildID;

            using var logScope = MessageLogMessages.BeginMessageNotificationScope(_logger, guild.Value.Value, channel.Value, notification.ID.Value);

            MessageLogMessages.MessageReceivedHandling(_logger);

            await TryTrackMessageAsync(
                guild,
                message,
                async (guildId) =>
            {
                MessageLogMessages.MessageRecordCreating(_logger);
                await _messageRepository.CreateAsync(new MessageCreationData()
                {
                    Id        = message.ID.Value,
                    GuildId   = guildId,
                    ChannelId = channel.Value,
                    AuthorId  = message.Author.ID.Value,
                    Timestamp = message.Timestamp
                });
                MessageLogMessages.MessageRecordCreated(_logger);
            });

            MessageLogMessages.MessageReceivedHandled(_logger);
        }