Skip to content

Commit

Permalink
Refactoring: Extract code from exchangeService
Browse files Browse the repository at this point in the history
  • Loading branch information
@Compile-Ninja
Compile-Ninja committed Sep 25, 2024
1 parent 1e2a4f4 commit fb2e6a2
Show file tree
Hide file tree
Showing 2 changed files with 246 additions and 223 deletions.
225 changes: 2 additions & 223 deletions src/main/java/org/prebid/server/auction/ExchangeService.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -75,9 +75,6 @@
import org.prebid.server.hooks.execution.model.HookStageExecutionResult;
import org.prebid.server.hooks.execution.model.Stage;
import org.prebid.server.hooks.execution.model.StageExecutionOutcome;
import org.prebid.server.hooks.v1.analytics.AppliedTo;
import org.prebid.server.hooks.v1.analytics.Result;
import org.prebid.server.hooks.v1.analytics.Tags;
import org.prebid.server.hooks.v1.bidder.BidderRequestPayload;
import org.prebid.server.hooks.v1.bidder.BidderResponsePayload;
import org.prebid.server.json.JacksonMapper;
Expand Down Expand Up @@ -109,22 +106,11 @@
import org.prebid.server.proto.openrtb.ext.request.ExtSite;
import org.prebid.server.proto.openrtb.ext.request.ExtUser;
import org.prebid.server.proto.openrtb.ext.request.ImpMediaType;
import org.prebid.server.proto.openrtb.ext.request.TraceLevel;
import org.prebid.server.proto.openrtb.ext.response.ExtAnalytics;
import org.prebid.server.proto.openrtb.ext.response.ExtAnalyticsTags;
import org.prebid.server.proto.openrtb.ext.response.ExtBidResponse;
import org.prebid.server.proto.openrtb.ext.response.ExtBidResponsePrebid;
import org.prebid.server.proto.openrtb.ext.response.ExtBidderError;
import org.prebid.server.proto.openrtb.ext.response.ExtModules;
import org.prebid.server.proto.openrtb.ext.response.ExtModulesTrace;
import org.prebid.server.proto.openrtb.ext.response.ExtModulesTraceAnalyticsActivity;
import org.prebid.server.proto.openrtb.ext.response.ExtModulesTraceAnalyticsAppliedTo;
import org.prebid.server.proto.openrtb.ext.response.ExtModulesTraceAnalyticsResult;
import org.prebid.server.proto.openrtb.ext.response.ExtModulesTraceAnalyticsTags;
import org.prebid.server.proto.openrtb.ext.response.ExtModulesTraceGroup;
import org.prebid.server.proto.openrtb.ext.response.ExtModulesTraceInvocationResult;
import org.prebid.server.proto.openrtb.ext.response.ExtModulesTraceStage;
import org.prebid.server.proto.openrtb.ext.response.ExtModulesTraceStageOutcome;
import org.prebid.server.settings.model.Account;
import org.prebid.server.settings.model.AccountAnalyticsConfig;
import org.prebid.server.util.HttpUtil;
Expand All @@ -147,7 +133,6 @@
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

Expand Down Expand Up @@ -265,7 +250,7 @@ public Future<AuctionContext> holdAuction(AuctionContext context) {
return processAuctionRequest(context)
.compose(this::invokeResponseHooks)
.map(this::enrichWithAnalyticsTags)
.map(this::enrichWithHooksDebugInfo)
.map(HookDebugInfoEnricher::enrichWithHooksDebugInfo)
.map(this::updateHooksMetrics);
}

Expand Down Expand Up @@ -1610,7 +1595,7 @@ private AuctionContext enrichWithAnalyticsTags(AuctionContext context) {
return addClientDetailsWarning(context);
}

final List<ExtAnalyticsTags> extAnalyticsTags = toExtAnalyticsTags(context);
final List<ExtAnalyticsTags> extAnalyticsTags = HookDebugInfoEnricher.toExtAnalyticsTags(context);

if (extAnalyticsTags == null) {
return context;
Expand Down Expand Up @@ -1690,212 +1675,6 @@ private static AuctionContext addClientDetailsWarning(AuctionContext context) {
return context.with(updatedBidResponse);
}

private AuctionContext enrichWithHooksDebugInfo(AuctionContext context) {
final ExtModules extModules = toExtModules(context);

if (extModules == null) {
return context;
}

final BidResponse bidResponse = context.getBidResponse();
final Optional<ExtBidResponse> ext = Optional.ofNullable(bidResponse.getExt());
final Optional<ExtBidResponsePrebid> extPrebid = ext.map(ExtBidResponse::getPrebid);

final ExtBidResponsePrebid updatedExtPrebid = extPrebid
.map(ExtBidResponsePrebid::toBuilder)
.orElse(ExtBidResponsePrebid.builder())
.modules(extModules)
.build();

final ExtBidResponse updatedExt = ext
.map(ExtBidResponse::toBuilder)
.orElse(ExtBidResponse.builder())
.prebid(updatedExtPrebid)
.build();

final BidResponse updatedBidResponse = bidResponse.toBuilder().ext(updatedExt).build();
return context.with(updatedBidResponse);
}

private static ExtModules toExtModules(AuctionContext context) {
final Map<String, Map<String, List<String>>> errors =
toHookMessages(context, HookExecutionOutcome::getErrors);
final Map<String, Map<String, List<String>>> warnings =
toHookMessages(context, HookExecutionOutcome::getWarnings);
final ExtModulesTrace trace = toHookTrace(context);
return ObjectUtils.anyNotNull(errors, warnings, trace) ? ExtModules.of(errors, warnings, trace) : null;
}

private static Map<String, Map<String, List<String>>> toHookMessages(
AuctionContext context,
Function<HookExecutionOutcome, List<String>> messagesGetter) {

if (!context.getDebugContext().isDebugEnabled()) {
return null;
}

final Map<String, List<HookExecutionOutcome>> hookOutcomesByModule =
context.getHookExecutionContext().getStageOutcomes().values().stream()
.flatMap(Collection::stream)
.flatMap(stageOutcome -> stageOutcome.getGroups().stream())
.flatMap(groupOutcome -> groupOutcome.getHooks().stream())
.filter(hookOutcome -> CollectionUtils.isNotEmpty(messagesGetter.apply(hookOutcome)))
.collect(Collectors.groupingBy(
hookOutcome -> hookOutcome.getHookId().getModuleCode()));

final Map<String, Map<String, List<String>>> messagesByModule = hookOutcomesByModule.entrySet().stream()
.collect(Collectors.toMap(
Map.Entry::getKey,
outcomes -> outcomes.getValue().stream()
.collect(Collectors.groupingBy(
hookOutcome -> hookOutcome.getHookId().getHookImplCode()))
.entrySet().stream()
.collect(Collectors.toMap(
Map.Entry::getKey,
messagesLists -> messagesLists.getValue().stream()
.map(messagesGetter)
.flatMap(Collection::stream)
.toList()))));

return !messagesByModule.isEmpty() ? messagesByModule : null;
}

private static ExtModulesTrace toHookTrace(AuctionContext context) {
final TraceLevel traceLevel = context.getDebugContext().getTraceLevel();

if (traceLevel == null) {
return null;
}

final List<ExtModulesTraceStage> stages = context.getHookExecutionContext().getStageOutcomes()
.entrySet().stream()
.map(stageOutcome -> toTraceStage(stageOutcome.getKey(), stageOutcome.getValue(), traceLevel))
.filter(Objects::nonNull)
.toList();

if (stages.isEmpty()) {
return null;
}

final long executionTime = stages.stream().mapToLong(ExtModulesTraceStage::getExecutionTime).sum();
return ExtModulesTrace.of(executionTime, stages);
}

private static ExtModulesTraceStage toTraceStage(Stage stage,
List<StageExecutionOutcome> stageOutcomes,
TraceLevel level) {

final List<ExtModulesTraceStageOutcome> extStageOutcomes = stageOutcomes.stream()
.map(stageOutcome -> toTraceStageOutcome(stageOutcome, level))
.filter(Objects::nonNull)
.toList();

if (extStageOutcomes.isEmpty()) {
return null;
}

final long executionTime = extStageOutcomes.stream()
.mapToLong(ExtModulesTraceStageOutcome::getExecutionTime)
.max()
.orElse(0L);

return ExtModulesTraceStage.of(stage, executionTime, extStageOutcomes);
}

private static ExtModulesTraceStageOutcome toTraceStageOutcome(
StageExecutionOutcome stageOutcome, TraceLevel level) {

final List<ExtModulesTraceGroup> groups = stageOutcome.getGroups().stream()
.map(group -> toTraceGroup(group, level))
.toList();

if (groups.isEmpty()) {
return null;
}

final long executionTime = groups.stream().mapToLong(ExtModulesTraceGroup::getExecutionTime).sum();
return ExtModulesTraceStageOutcome.of(stageOutcome.getEntity(), executionTime, groups);
}

private static ExtModulesTraceGroup toTraceGroup(GroupExecutionOutcome group, TraceLevel level) {
final List<ExtModulesTraceInvocationResult> invocationResults = group.getHooks().stream()
.map(hook -> toTraceInvocationResult(hook, level))
.toList();

final long executionTime = invocationResults.stream()
.mapToLong(ExtModulesTraceInvocationResult::getExecutionTime)
.max()
.orElse(0L);

return ExtModulesTraceGroup.of(executionTime, invocationResults);
}

private static ExtModulesTraceInvocationResult toTraceInvocationResult(HookExecutionOutcome hook,
TraceLevel level) {
return ExtModulesTraceInvocationResult.builder()
.hookId(hook.getHookId())
.executionTime(hook.getExecutionTime())
.status(hook.getStatus())
.message(hook.getMessage())
.action(hook.getAction())
.debugMessages(level == TraceLevel.verbose ? hook.getDebugMessages() : null)
.analyticsTags(level == TraceLevel.verbose ? toTraceAnalyticsTags(hook.getAnalyticsTags()) : null)
.build();
}

private static ExtModulesTraceAnalyticsTags toTraceAnalyticsTags(Tags analyticsTags) {
if (analyticsTags == null) {
return null;
}

return ExtModulesTraceAnalyticsTags.of(CollectionUtils.emptyIfNull(analyticsTags.activities()).stream()
.filter(Objects::nonNull)
.map(ExchangeService::toTraceAnalyticsActivity)
.toList());
}

private static ExtModulesTraceAnalyticsActivity toTraceAnalyticsActivity(
org.prebid.server.hooks.v1.analytics.Activity activity) {

return ExtModulesTraceAnalyticsActivity.of(
activity.name(),
activity.status(),
CollectionUtils.emptyIfNull(activity.results()).stream()
.filter(Objects::nonNull)
.map(ExchangeService::toTraceAnalyticsResult)
.toList());
}

private static ExtModulesTraceAnalyticsResult toTraceAnalyticsResult(Result result) {
final AppliedTo appliedTo = result.appliedTo();
final ExtModulesTraceAnalyticsAppliedTo extAppliedTo = appliedTo != null
? ExtModulesTraceAnalyticsAppliedTo.builder()
.impIds(appliedTo.impIds())
.bidders(appliedTo.bidders())
.request(appliedTo.request() ? Boolean.TRUE : null)
.response(appliedTo.response() ? Boolean.TRUE : null)
.bidIds(appliedTo.bidIds())
.build()
: null;

return ExtModulesTraceAnalyticsResult.of(result.status(), result.values(), extAppliedTo);
}

private static List<ExtAnalyticsTags> toExtAnalyticsTags(AuctionContext context) {
return context.getHookExecutionContext().getStageOutcomes().entrySet().stream()
.flatMap(stageToExecutionOutcome -> stageToExecutionOutcome.getValue().stream()
.map(StageExecutionOutcome::getGroups)
.flatMap(Collection::stream)
.map(GroupExecutionOutcome::getHooks)
.flatMap(Collection::stream)
.filter(hookExecutionOutcome -> hookExecutionOutcome.getAnalyticsTags() != null)
.map(hookExecutionOutcome -> ExtAnalyticsTags.of(
stageToExecutionOutcome.getKey(),
hookExecutionOutcome.getHookId().getModuleCode(),
toTraceAnalyticsTags(hookExecutionOutcome.getAnalyticsTags()))))
.toList();
}

private AuctionContext updateHooksMetrics(AuctionContext context) {
final EnumMap<Stage, List<StageExecutionOutcome>> stageOutcomes =
context.getHookExecutionContext().getStageOutcomes();
Expand Down
Loading

0 comments on commit fb2e6a2

Please sign in to comment.