Sheldan/abstracto
1
0
Fork 0
mirror of https://github.com/Sheldan/abstracto.git synced 2026-04-16 12:28:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

[AB-xxx] try for instrumenting

Browse Source
This commit is contained in:
Sheldan
2024-09-29 09:23:03 +02:00
parent c791c063e3
commit 0d5b7c5855
32 changed files with 435 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
abstracto-application/abstracto-modules/anti-raid/anti-raid-impl/src/main/java/dev/sheldan/abstracto/antiraid/listener/MassPingMessageListener.java
View File

@@ -6,6 +6,8 @@ import dev.sheldan.abstracto.core.config.FeatureDefinition;
import dev.sheldan.abstracto.core.listener.DefaultListenerResult;
import dev.sheldan.abstracto.core.listener.async.jda.AsyncMessageReceivedListener;
import dev.sheldan.abstracto.core.models.listener.MessageReceivedModel;
import io.micrometer.tracing.Span;
import io.micrometer.tracing.Tracer;
import lombok.extern.slf4j.Slf4j;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.channel.ChannelType;
@@ -19,13 +21,22 @@ public class MassPingMessageListener implements AsyncMessageReceivedListener {
@Autowired
private MassPingService massPingService;
@Autowired
private Tracer tracer;
@Override
public DefaultListenerResult execute(MessageReceivedModel model) {
Message message = model.getMessage();
if(message.getAuthor().isBot() || message.isWebhookMessage() || !message.isFromGuild() || !message.isFromType(ChannelType.TEXT)) {
return DefaultListenerResult.IGNORED;
Span newSpan = tracer.nextSpan().name("mass-ping-filter");
try (Tracer.SpanInScope ws = this.tracer.withSpan(newSpan.start())) {
Message message = model.getMessage();
if (message.getAuthor().isBot() || message.isWebhookMessage() || !message.isFromGuild() || !message.isFromType(ChannelType.TEXT)) {
newSpan.end();
return DefaultListenerResult.IGNORED;
}
massPingService.processMessage(message).whenComplete((unused, throwable) -> {
newSpan.end();
});
}
massPingService.processMessage(message);
return DefaultListenerResult.PROCESSED;
}

21
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/command/Rank.java
View File

@@ -27,6 +27,8 @@ import dev.sheldan.abstracto.experience.service.ExperienceLevelService;
import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService;
import dev.sheldan.abstracto.core.templating.model.MessageToSend;
import dev.sheldan.abstracto.core.templating.service.TemplateService;
import io.micrometer.tracing.Span;
import io.micrometer.tracing.Tracer;
import lombok.extern.slf4j.Slf4j;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
@@ -83,11 +85,14 @@ public class Rank extends AbstractConditionableCommand {
@Value("${abstracto.experience.leaderboard.externalUrl}")
private String leaderboardExternalURL;
@Autowired
private Tracer tracer;
@Override
public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
List<Object> parameters = commandContext.getParameters().getParameters();
Member targetMember = !parameters.isEmpty() ? (Member) parameters.get(0) : commandContext.getAuthor();
if(!targetMember.getGuild().equals(commandContext.getGuild())) {
if (!targetMember.getGuild().equals(commandContext.getGuild())) {
throw new EntityGuildMismatchException();
}
AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(targetMember);
@@ -97,10 +102,13 @@ public class Rank extends AbstractConditionableCommand {
.builder()
.member(targetMember)
.build();
Span span = tracer.currentSpan();
return future.thenCompose(leaderBoardEntryModel -> {
try (Tracer.SpanInScope ws = tracer.withSpan(span)) {
MessageToSend messageToSend = self.renderMessageToSend(targetMember, rankModel, leaderBoardEntryModel.get(0));
return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()));
}).thenApply(result -> CommandResult.fromIgnored());
}
}).thenApply(result -> CommandResult.fromIgnored());
}
@Transactional
@@ -133,7 +141,7 @@ public class Rank extends AbstractConditionableCommand {
@Override
public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
Member targetMember;
if(slashCommandParameterService.hasCommandOption(MEMBER_PARAMETER, event)) {
if (slashCommandParameterService.hasCommandOption(MEMBER_PARAMETER, event)) {
targetMember = slashCommandParameterService.getCommandOption(MEMBER_PARAMETER, event, Member.class);
} else {
targetMember = event.getMember();
@@ -145,9 +153,12 @@ public class Rank extends AbstractConditionableCommand {
.builder()
.member(targetMember)
.build();
Span span = tracer.currentSpan();
return future.thenCompose(leaderBoardEntryModel -> {
MessageToSend messageToSend = self.renderMessageToSend(targetMember, rankModel, leaderBoardEntryModel.get(0));
return interactionService.replyMessageToSend(messageToSend, event);
try (Tracer.SpanInScope ws = tracer.withSpan(span)) {
MessageToSend messageToSend = self.renderMessageToSend(targetMember, rankModel, leaderBoardEntryModel.get(0));
return interactionService.replyMessageToSend(messageToSend, event);
}
}).thenApply(result -> CommandResult.fromIgnored());
}

21
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/converter/LeaderBoardModelConverter.java
View File

@@ -4,7 +4,8 @@ import dev.sheldan.abstracto.core.service.MemberService;
import dev.sheldan.abstracto.experience.model.LeaderBoard;
import dev.sheldan.abstracto.experience.model.LeaderBoardEntry;
import dev.sheldan.abstracto.experience.model.template.LeaderBoardEntryModel;
import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService;
import io.micrometer.tracing.Span;
import io.micrometer.tracing.Tracer;
import lombok.extern.slf4j.Slf4j;
import net.dv8tion.jda.api.entities.Member;
import org.springframework.beans.factory.annotation.Autowired;
@@ -29,10 +30,7 @@ public class LeaderBoardModelConverter {
private MemberService memberService;
@Autowired
private UserExperienceManagementService userExperienceManagementService;
@Autowired
private LeaderBoardModelConverter self;
private Tracer tracer;
/**
* Converts the complete {@link LeaderBoard leaderBoard} into a list of {@link LeaderBoardEntryModel leaderbaordEntryModels} which contain additional
@@ -62,12 +60,15 @@ public class LeaderBoardModelConverter {
.build();
})
.collect(Collectors.toMap(LeaderBoardEntryModel::getUserId, Function.identity()));
Span span = tracer.currentSpan();
return memberService.getMembersInServerAsync(serverId, userIds).thenApply(members -> {
members.forEach(member -> models.get(member.getIdLong()).setMember(member));
return new ArrayList<>(models.values())
.stream()
.sorted(Comparator.comparing(LeaderBoardEntryModel::getRank)).
collect(Collectors.toList());
try (Tracer.SpanInScope ws = tracer.withSpan(span)) {
members.forEach(member -> models.get(member.getIdLong()).setMember(member));
return new ArrayList<>(models.values())
.stream()
.sorted(Comparator.comparing(LeaderBoardEntryModel::getRank)).
collect(Collectors.toList());
}
});
}
}

29
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/listener/ExperienceTrackerListener.java
View File

@@ -7,6 +7,8 @@ import dev.sheldan.abstracto.core.listener.sync.jda.MessageReceivedListener;
import dev.sheldan.abstracto.core.models.listener.MessageReceivedModel;
import dev.sheldan.abstracto.experience.config.ExperienceFeatureDefinition;
import dev.sheldan.abstracto.experience.service.AUserExperienceService;
import io.micrometer.tracing.Span;
import io.micrometer.tracing.Tracer;
import lombok.extern.slf4j.Slf4j;
import net.dv8tion.jda.api.entities.Message;
import org.springframework.beans.factory.annotation.Autowired;
@@ -23,17 +25,26 @@ public class ExperienceTrackerListener implements AsyncMessageReceivedListener {
@Autowired
private AUserExperienceService userExperienceService;
@Autowired
private Tracer tracer;
@Override
public DefaultListenerResult execute(MessageReceivedModel model) {
Message message = model.getMessage();
if(!message.isFromGuild() || message.isWebhookMessage() || message.getType().isSystem() || message.getAuthor().isBot()) {
return DefaultListenerResult.IGNORED;
}
if(userExperienceService.experienceGainEnabledInChannel(message.getChannel())) {
userExperienceService.addExperience(message.getMember(), model.getMessage());
return DefaultListenerResult.PROCESSED;
} else {
return DefaultListenerResult.IGNORED;
Span newSpan = tracer.nextSpan().name("experience-tracker");
try (Tracer.SpanInScope ws = this.tracer.withSpan(newSpan.start())) {
Message message = model.getMessage();
if(!message.isFromGuild() || message.isWebhookMessage() || message.getType().isSystem() || message.getAuthor().isBot()) {
newSpan.end();
return DefaultListenerResult.IGNORED;
}
if(userExperienceService.experienceGainEnabledInChannel(message.getChannel())) {
userExperienceService.addExperience(message.getMember(), model.getMessage()).whenComplete((unused, throwable) -> {
newSpan.end();
});
return DefaultListenerResult.PROCESSED;
} else {
return DefaultListenerResult.IGNORED;
}
}
}

76
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/AUserExperienceServiceBean.java
View File

@@ -1,5 +1,6 @@
package dev.sheldan.abstracto.experience.service;
import dev.sheldan.abstracto.core.metric.service.MetricUtils;
import dev.sheldan.abstracto.core.models.database.*;
import dev.sheldan.abstracto.core.models.template.display.MemberDisplay;
import dev.sheldan.abstracto.core.models.template.display.RoleDisplay;
@@ -25,6 +26,8 @@ import dev.sheldan.abstracto.experience.service.management.DisabledExpRoleManage
import dev.sheldan.abstracto.experience.service.management.ExperienceLevelManagementService;
import dev.sheldan.abstracto.experience.service.management.ExperienceRoleManagementService;
import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService;
import io.micrometer.tracing.Span;
import io.micrometer.tracing.Tracer;
import lombok.extern.slf4j.Slf4j;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.api.entities.Message;
@@ -114,8 +117,11 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
@Qualifier("experienceUpdateExecutor")
private TaskExecutor experienceUpdateExecutor;
@Autowired
private Tracer tracer;
@Override
public void addExperience(Member member, Message message) {
public CompletableFuture<Void> addExperience(Member member, Message message) {
runTimeExperienceService.takeLock();
try {
Map<Long, Map<Long, Instant>> runtimeExperience = runTimeExperienceService.getRuntimeExperience();
@@ -141,7 +147,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
// we store when the user is eligible for experience _again_
Long maxSeconds = configService.getLongValueOrConfigDefault(EXP_COOLDOWN_SECONDS_KEY, serverId);
serverExperience.put(userId, Instant.now().plus(maxSeconds, ChronoUnit.SECONDS));
CompletableFuture.runAsync(() -> self.addExperienceToMember(member, message), experienceUpdateExecutor).exceptionally(throwable -> {
return CompletableFuture.runAsync(() -> self.addExperienceToMember(member, message), MetricUtils.wrapExecutor(experienceUpdateExecutor)).exceptionally(throwable -> {
log.error("Failed to add experience to member {} in server {}.", message.getAuthor().getId(), message.getGuild().getIdLong(), throwable);
return null;
});
@@ -149,6 +155,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
} finally {
runTimeExperienceService.releaseLock();
}
return CompletableFuture.completedFuture(null);
}
@@ -297,37 +304,43 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
}
@Transactional
public void addExperienceToMember(Member member, Message message) {
long serverId = member.getGuild().getIdLong();
AServer server = serverManagementService.loadOrCreate(serverId);
List<ADisabledExpRole> disabledExpRoles = disabledExpRoleManagementService.getDisabledRolesForServer(server);
List<ARole> disabledRoles = disabledExpRoles
.stream()
.map(ADisabledExpRole::getRole)
.collect(Collectors.toList());
if(roleService.hasAnyOfTheRoles(member, disabledRoles)) {
log.debug("User {} has a experience disable role in server {} - not giving any experience.", member.getIdLong(), serverId);
return;
}
AUserInAServer userInAServer = userInServerManagementService.loadOrCreateUser(member);
Long userInServerId = userInAServer.getUserInServerId();
Optional<AUserExperience> aUserExperienceOptional = userExperienceManagementService.findByUserInServerIdOptional(userInAServer.getUserInServerId());
AUserExperience aUserExperience = aUserExperienceOptional.orElseGet(() -> userExperienceManagementService.createUserInServer(userInAServer));
if(Boolean.FALSE.equals(aUserExperience.getExperienceGainDisabled())) {
List<AExperienceLevel> levels = experienceLevelManagementService.getLevelConfig();
levels.sort(Comparator.comparing(AExperienceLevel::getExperienceNeeded));
public CompletableFuture<Void> addExperienceToMember(Member member, Message message) {
CompletableFuture<Void> notificationFuture = CompletableFuture.completedFuture(null);
CompletableFuture<Void> levelActionFuture = CompletableFuture.completedFuture(null);
CompletableFuture<Void> roleFuture = CompletableFuture.completedFuture(null);
Span newSpan = tracer.nextSpan().name("experience-adding");
try (Tracer.SpanInScope ws = this.tracer.withSpan(newSpan.start())) {
long serverId = member.getGuild().getIdLong();
AServer server = serverManagementService.loadOrCreate(serverId);
List<ADisabledExpRole> disabledExpRoles = disabledExpRoleManagementService.getDisabledRolesForServer(server);
List<ARole> disabledRoles = disabledExpRoles
.stream()
.map(ADisabledExpRole::getRole)
.collect(Collectors.toList());
if (roleService.hasAnyOfTheRoles(member, disabledRoles)) {
log.debug("User {} has a experience disable role in server {} - not giving any experience.", member.getIdLong(), serverId);
newSpan.end();
return CompletableFuture.completedFuture(null);
}
AUserInAServer userInAServer = userInServerManagementService.loadOrCreateUser(member);
Long userInServerId = userInAServer.getUserInServerId();
Optional<AUserExperience> aUserExperienceOptional = userExperienceManagementService.findByUserInServerIdOptional(userInAServer.getUserInServerId());
AUserExperience aUserExperience = aUserExperienceOptional.orElseGet(() -> userExperienceManagementService.createUserInServer(userInAServer));
if (Boolean.FALSE.equals(aUserExperience.getExperienceGainDisabled())) {
List<AExperienceLevel> levels = experienceLevelManagementService.getLevelConfig();
levels.sort(Comparator.comparing(AExperienceLevel::getExperienceNeeded));
Long minExp = configService.getLongValueOrConfigDefault(ExperienceFeatureConfig.MIN_EXP_KEY, serverId);
Long maxExp = configService.getLongValueOrConfigDefault(ExperienceFeatureConfig.MAX_EXP_KEY, serverId);
Double multiplier = configService.getDoubleValueOrConfigDefault(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, serverId);
Long experienceRange = maxExp - minExp + 1;
Long gainedExperience = (secureRandom.nextInt(experienceRange.intValue()) + minExp);
gainedExperience = (long) Math.floor(gainedExperience * multiplier);
Long minExp = configService.getLongValueOrConfigDefault(ExperienceFeatureConfig.MIN_EXP_KEY, serverId);
Long maxExp = configService.getLongValueOrConfigDefault(ExperienceFeatureConfig.MAX_EXP_KEY, serverId);
Double multiplier = configService.getDoubleValueOrConfigDefault(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, serverId);
Long experienceRange = maxExp - minExp + 1;
Long gainedExperience = (secureRandom.nextInt(experienceRange.intValue()) + minExp);
gainedExperience = (long) Math.floor(gainedExperience * multiplier);
List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(server);
roles.sort(Comparator.comparing(role -> role.getLevel().getLevel()));
List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(server);
roles.sort(Comparator.comparing(role -> role.getLevel().getLevel()));
log.debug("Handling {}. The user gains {}.", userInServerId, gainedExperience);
log.debug("Handling {}. The user gains {}.", userInServerId, gainedExperience);
Long oldExperience = aUserExperience.getExperience();
Long newExperienceCount = oldExperience + gainedExperience;
@@ -415,6 +428,9 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
} else {
log.debug("Experience gain was disabled. User did not gain any experience.");
}
return CompletableFuture.allOf(notificationFuture, levelActionFuture, roleFuture).whenComplete((unused, throwable) -> {
newSpan.end();
});
}
@Override

2
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/src/main/java/dev/sheldan/abstracto/experience/service/AUserExperienceService.java
View File

@@ -20,7 +20,7 @@ import java.util.concurrent.CompletableFuture;
*/
public interface AUserExperienceService {
String EXPERIENCE_GAIN_CHANNEL_GROUP_KEY = "experienceGain";
void addExperience(Member member, Message message);
CompletableFuture<Void> addExperience(Member member, Message message);
/**
* Calculates the appropriate level for the given experience amount according to the given {@link AExperienceLevel levels}

62
abstracto-application/abstracto-modules/invite-filter/invite-filter-impl/src/main/java/dev/sheldan/abstracto/invitefilter/listener/InviteLinkFilterListener.java
View File

@@ -7,6 +7,8 @@ import dev.sheldan.abstracto.core.models.listener.MessageReceivedModel;
import dev.sheldan.abstracto.invitefilter.config.InviteFilterFeatureDefinition;
import dev.sheldan.abstracto.invitefilter.service.InviteLinkFilterService;
import dev.sheldan.abstracto.invitefilter.service.InviteLinkFilterServiceBean;
import io.micrometer.tracing.Span;
import io.micrometer.tracing.Tracer;
import lombok.extern.slf4j.Slf4j;
import net.dv8tion.jda.api.entities.Message;
import org.springframework.beans.factory.annotation.Autowired;
@@ -24,6 +26,9 @@ public class InviteLinkFilterListener implements AsyncMessageReceivedListener {
@Autowired
private InviteLinkFilterServiceBean filterServiceBean;
@Autowired
private Tracer tracer;
@Override
public FeatureDefinition getFeature() {
return InviteFilterFeatureDefinition.INVITE_FILTER;
@@ -31,31 +36,40 @@ public class InviteLinkFilterListener implements AsyncMessageReceivedListener {
@Override
public DefaultListenerResult execute(MessageReceivedModel model) {
Message message = model.getMessage();
Span newSpan = tracer.nextSpan().name("invite-filter");
try (Tracer.SpanInScope ws = this.tracer.withSpan(newSpan.start())) {
Message message = model.getMessage();
if(!message.isFromGuild() || message.isWebhookMessage() || message.getType().isSystem()) {
return DefaultListenerResult.IGNORED;
if (!message.isFromGuild() || message.isWebhookMessage() || message.getType().isSystem()) {
newSpan.end();
return DefaultListenerResult.IGNORED;
}
List<String> foundInvites = inviteLinkFilterService.findInvitesInMessage(message);
if (foundInvites.isEmpty()) {
newSpan.end();
return DefaultListenerResult.IGNORED;
}
if (!inviteLinkFilterService.isInviteFilterActiveInChannel(message.getChannel())) {
newSpan.end();
return DefaultListenerResult.IGNORED;
}
if (inviteLinkFilterService.isMemberImmuneAgainstInviteFilter(message.getMember())) {
log.info("Not checking for invites in message, because author {} in channel {} in guild {} is immune against invite filter.",
message.getMember().getIdLong(), message.getGuild().getIdLong(), message.getChannel().getIdLong());
newSpan.end();
return DefaultListenerResult.IGNORED;
}
// only to reduce code duplication, the interface is too concrete
filterServiceBean.resolveAndCheckInvites(message, foundInvites).whenComplete((unused, throwable) -> {
newSpan.end();
});
return DefaultListenerResult.PROCESSED;
}
List<String> foundInvites = inviteLinkFilterService.findInvitesInMessage(message);
if(foundInvites.isEmpty()){
return DefaultListenerResult.IGNORED;
}
if(!inviteLinkFilterService.isInviteFilterActiveInChannel(message.getChannel())) {
return DefaultListenerResult.IGNORED;
}
if(inviteLinkFilterService.isMemberImmuneAgainstInviteFilter(message.getMember())) {
log.info("Not checking for invites in message, because author {} in channel {} in guild {} is immune against invite filter.",
message.getMember().getIdLong(), message.getGuild().getIdLong(), message.getChannel().getIdLong());
return DefaultListenerResult.IGNORED;
}
// only to reduce code duplication, the interface is too concrete
filterServiceBean.resolveAndCheckInvites(message, foundInvites);
return DefaultListenerResult.PROCESSED;
}
}

14
abstracto-application/abstracto-modules/invite-filter/invite-filter-impl/src/main/java/dev/sheldan/abstracto/invitefilter/service/InviteLinkFilterServiceBean.java
View File

@@ -303,12 +303,13 @@ public class InviteLinkFilterServiceBean implements InviteLinkFilterService {
return foundInvites;
}
public void resolveAndCheckInvites(Message message, List<String> foundInvites) {
public CompletableFuture<Void> resolveAndCheckInvites(Message message, List<String> foundInvites) {
List<CompletableFuture<Invite>> inviteList = new ArrayList<>();
JDA jda = message.getJDA();
foundInvites.forEach(s -> inviteList.add(resolveInvite(jda, s)));
CompletableFutureList<Invite> list = new CompletableFutureList<>(inviteList);
CompletableFuture<Void> returningFuture = new CompletableFuture<>();
list.getMainFuture().whenComplete((unused, throwable) -> {
List<Invite> invites = list.getObjects();
Long serverId = message.getGuild().getIdLong();
@@ -353,24 +354,31 @@ public class InviteLinkFilterServiceBean implements InviteLinkFilterService {
}
if(toDelete) {
metricService.incrementCounter(MESSAGE_INVITE_FILTERED);
messageService.deleteMessage(message);
CompletableFuture<Void> deletionFuture = messageService.deleteMessage(message);
CompletableFuture<Void> notificationFuture = CompletableFuture.completedFuture(null);
boolean trackUsages = featureModeService.featureModeActive(InviteFilterFeatureDefinition.INVITE_FILTER, serverId, InviteFilterMode.TRACK_USES);
if(trackUsages) {
targetServers.forEach((targetServerId, serverName) -> storeFilteredInviteLinkUsage(targetServerId, serverName, author));
}
boolean sendNotification = featureModeService.featureModeActive(InviteFilterFeatureDefinition.INVITE_FILTER, serverId, InviteFilterMode.FILTER_NOTIFICATIONS);
if(sendNotification) {
sendDeletionNotification(deletedInvites, message)
notificationFuture = sendDeletionNotification(deletedInvites, message)
.thenAccept(unused1 -> log.info("Sent invite deletion notification.")).exceptionally(throwable1 -> {
log.error("Failed to send invite deletion notification.");
return null;
});
}
CompletableFuture.allOf(deletionFuture, notificationFuture).whenComplete((unused1, throwable1) -> {
returningFuture.complete(null);
});
}
}).exceptionally(throwable -> {
log.error("Invite matching failed.", throwable);
returningFuture.complete(null);
return null;
});
return returningFuture;
}
@PostConstruct

42
abstracto-application/abstracto-modules/profanity-filter/profanity-filter-impl/src/main/java/dev/sheldan/abstracto/profanityfilter/listener/ProfanityMessageReceivedListener.java
View File

@@ -9,6 +9,8 @@ import dev.sheldan.abstracto.core.service.ProfanityService;
import dev.sheldan.abstracto.profanityfilter.config.ProfanityFilterFeatureDefinition;
import dev.sheldan.abstracto.profanityfilter.service.ProfanityFilterService;
import dev.sheldan.abstracto.profanityfilter.service.ProfanityFilterServiceBean;
import io.micrometer.tracing.Span;
import io.micrometer.tracing.Tracer;
import lombok.extern.slf4j.Slf4j;
import net.dv8tion.jda.api.entities.Message;
import org.springframework.beans.factory.annotation.Autowired;
@@ -29,25 +31,35 @@ public class ProfanityMessageReceivedListener implements AsyncMessageReceivedLis
@Autowired
private ProfanityFilterServiceBean profanityFilterServiceBean;
@Autowired
private Tracer tracer;
@Override
public DefaultListenerResult execute(MessageReceivedModel model) {
Message message = model.getMessage();
if(message.isWebhookMessage() || message.getType().isSystem() || !message.isFromGuild()) {
return DefaultListenerResult.IGNORED;
}
Span newSpan = tracer.nextSpan().name("profanity-filter");
try (Tracer.SpanInScope ws = this.tracer.withSpan(newSpan.start())) {
Message message = model.getMessage();
if (message.isWebhookMessage() || message.getType().isSystem() || !message.isFromGuild()) {
newSpan.end();
return DefaultListenerResult.IGNORED;
}
if(profanityFilterService.isImmuneAgainstProfanityFilter(message.getMember())) {
log.debug("Not checking for profanities in message, because author {} in channel {} in guild {} is immune against profanity filter.",
message.getMember().getIdLong(), message.getGuild().getIdLong(), message.getChannel().getIdLong());
return DefaultListenerResult.IGNORED;
}
if (profanityFilterService.isImmuneAgainstProfanityFilter(message.getMember())) {
log.debug("Not checking for profanities in message, because author {} in channel {} in guild {} is immune against profanity filter.",
message.getMember().getIdLong(), message.getGuild().getIdLong(), message.getChannel().getIdLong());
newSpan.end();
return DefaultListenerResult.IGNORED;
}
Long serverId = model.getServerId();
Optional<ProfanityRegex> potentialProfanityGroup = profanityService.getProfanityRegex(message.getContentRaw(), serverId);
if(potentialProfanityGroup.isPresent()) {
ProfanityRegex foundProfanityGroup = potentialProfanityGroup.get();
profanityFilterServiceBean.handleProfaneMessage(message, foundProfanityGroup);
return DefaultListenerResult.PROCESSED;
Long serverId = model.getServerId();
Optional<ProfanityRegex> potentialProfanityGroup = profanityService.getProfanityRegex(message.getContentRaw(), serverId);
if (potentialProfanityGroup.isPresent()) {
ProfanityRegex foundProfanityGroup = potentialProfanityGroup.get();
profanityFilterServiceBean.handleProfaneMessage(message, foundProfanityGroup).whenComplete((unused, throwable) -> {
newSpan.end();
});
return DefaultListenerResult.PROCESSED;
}
}
return DefaultListenerResult.IGNORED;
}

7
abstracto-application/abstracto-modules/profanity-filter/profanity-filter-impl/src/main/java/dev/sheldan/abstracto/profanityfilter/service/ProfanityFilterServiceBean.java
View File

@@ -238,22 +238,23 @@ public class ProfanityFilterServiceBean implements ProfanityFilterService {
return roleImmunityService.isImmune(member, PROFANITY_FILTER_EFFECT_KEY);
}
public void handleProfaneMessage(Message message, ProfanityRegex foundProfanityGroup) {
public CompletableFuture<Void> handleProfaneMessage(Message message, ProfanityRegex foundProfanityGroup) {
metricService.incrementCounter(PROFANITIES_DETECTED_METRIC);
if(featureModeService.featureModeActive(ProfanityFilterFeatureDefinition.PROFANITY_FILTER, message.getGuild().getIdLong(), ProfanityFilterMode.PROFANITY_REPORT)) {
createProfanityReport(message, foundProfanityGroup).exceptionally(throwable -> {
return createProfanityReport(message, foundProfanityGroup).exceptionally(throwable -> {
log.error("Failed to report or persist profanities in server {} for message {} in channel {}.",
message.getGuild().getIdLong(), message.getChannel().getIdLong(), message.getIdLong(), throwable);
return null;
});
}
if(featureModeService.featureModeActive(ProfanityFilterFeatureDefinition.PROFANITY_FILTER, message.getGuild().getIdLong(), ProfanityFilterMode.AUTO_DELETE_PROFANITIES)) {
messageService.deleteMessage(message).exceptionally(throwable -> {
return messageService.deleteMessage(message).exceptionally(throwable -> {
log.error("Failed to delete profanity message with id {} in channel {} in server {}.",
message.getIdLong(), message.getChannel().getIdLong(), message.getGuild().getIdLong(), throwable);
return null;
});
}
return CompletableFuture.completedFuture(null);
}
@PostConstruct

20
abstracto-application/abstracto-modules/statistic/statistic-impl/src/main/java/dev/sheldan/abstracto/statistic/emote/listener/EmoteTrackingListener.java
View File

@@ -8,6 +8,8 @@ import dev.sheldan.abstracto.core.service.GuildService;
import dev.sheldan.abstracto.statistic.config.StatisticFeatureDefinition;
import dev.sheldan.abstracto.statistic.emote.model.database.UsedEmoteType;
import dev.sheldan.abstracto.statistic.emote.service.TrackedEmoteService;
import io.micrometer.tracing.Span;
import io.micrometer.tracing.Tracer;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.emoji.CustomEmoji;
import org.springframework.beans.factory.annotation.Autowired;
@@ -30,13 +32,13 @@ public class EmoteTrackingListener implements AsyncMessageReceivedListener {
@Autowired
private GuildService guildService;
@Override
public FeatureDefinition getFeature() {
return StatisticFeatureDefinition.EMOTE_TRACKING;
}
@Autowired
private Tracer tracer;
@Override
public DefaultListenerResult execute(MessageReceivedModel model) {
Span newSpan = tracer.nextSpan().name("experience-tracker");
try (Tracer.SpanInScope ws = this.tracer.withSpan(newSpan.start())) {
Message message = model.getMessage();
if(!message.isFromGuild() || message.isWebhookMessage() || message.getType().isSystem()) {
return DefaultListenerResult.IGNORED;
@@ -50,5 +52,15 @@ public class EmoteTrackingListener implements AsyncMessageReceivedListener {
trackedEmoteService.addEmoteToRuntimeStorage(groupedEmotes.get(0), guildService.getGuildById(model.getServerId()), (long) groupedEmotes.size(), UsedEmoteType.MESSAGE)
);
return DefaultListenerResult.PROCESSED;
} finally {
newSpan.end();
}
}
@Override
public FeatureDefinition getFeature() {
return StatisticFeatureDefinition.EMOTE_TRACKING;
}
}