optable-targeting: Return fail for not properly configured account

Author: softcoder594

extra/modules/optable-targeting/src/main/java/org/prebid/server/hooks/modules/optable/targeting/config/OptableTargetingConfig.java

@@ -90,13 +90,15 @@ ConfigResolver configResolver(JsonMerger jsonMerger, OptableTargetingProperties
     OptableTargetingModule optableTargetingModule(ConfigResolver configResolver,
                                                   OptableTargeting optableTargeting,
                                                   UserFpdActivityMask userFpdActivityMask,
-                                                  JsonMerger jsonMerger) {
+                                                  JsonMerger jsonMerger,
+                                                  @Value("${logging.sampling-rate:0.01}") double logSamplingRate) {
 
         return new OptableTargetingModule(List.of(
                 new OptableTargetingProcessedAuctionRequestHook(
                         configResolver,
                         optableTargeting,
-                        userFpdActivityMask),
+                        userFpdActivityMask,
+                        logSamplingRate),
                 new OptableTargetingAuctionResponseHook(
                         configResolver,
                         ObjectMapperProvider.mapper(),

extra/modules/optable-targeting/src/main/java/org/prebid/server/hooks/modules/optable/targeting/v1/OptableTargetingProcessedAuctionRequestHook.java

@@ -4,6 +4,7 @@
 import com.iab.openrtb.request.Device;
 import com.iab.openrtb.request.User;
 import io.vertx.core.Future;
+import org.apache.commons.lang3.StringUtils;
 import org.prebid.server.activity.Activity;
 import org.prebid.server.activity.ComponentType;
 import org.prebid.server.activity.infrastructure.ActivityInfrastructure;
@@ -32,24 +33,32 @@
 import org.prebid.server.hooks.v1.auction.AuctionInvocationContext;
 import org.prebid.server.hooks.v1.auction.AuctionRequestPayload;
 import org.prebid.server.hooks.v1.auction.ProcessedAuctionRequestHook;
+import org.prebid.server.log.ConditionalLogger;
+import org.prebid.server.log.LoggerFactory;
 
 import java.util.Objects;
 
 public class OptableTargetingProcessedAuctionRequestHook implements ProcessedAuctionRequestHook {
 
+    private static final ConditionalLogger conditionalLogger = new ConditionalLogger(
+            LoggerFactory.getLogger(OptableTargetingProcessedAuctionRequestHook.class));
+
     public static final String CODE = "optable-targeting-processed-auction-request-hook";
 
     private final ConfigResolver configResolver;
     private final OptableTargeting optableTargeting;
     private final UserFpdActivityMask userFpdActivityMask;
+    private final double logSamplingRate;
 
     public OptableTargetingProcessedAuctionRequestHook(ConfigResolver configResolver,
                                                        OptableTargeting optableTargeting,
-                                                       UserFpdActivityMask userFpdActivityMask) {
+                                                       UserFpdActivityMask userFpdActivityMask,
+                                                       double logSamplingRate) {
 
         this.configResolver = Objects.requireNonNull(configResolver);
         this.optableTargeting = Objects.requireNonNull(optableTargeting);
         this.userFpdActivityMask = Objects.requireNonNull(userFpdActivityMask);
+        this.logSamplingRate = logSamplingRate;
     }
 
     @Override
@@ -58,6 +67,16 @@ public Future<InvocationResult<AuctionRequestPayload>> call(AuctionRequestPayloa
 
         final OptableTargetingProperties properties = configResolver.resolve(invocationContext.accountConfig());
         final ModuleContext moduleContext = new ModuleContext();
+        final long callTargetingAPITimestamp = System.currentTimeMillis();
+
+        if (!validateTargetingProperties(properties)) {
+            conditionalLogger.error(
+                    "Account not properly configured: tenant and/or origin is missing.", logSamplingRate);
+
+            moduleContext.setOptableTargetingExecutionTime(System.currentTimeMillis() - callTargetingAPITimestamp);
+            moduleContext.setEnrichRequestStatus(EnrichmentStatus.failure());
+            return update(BidRequestCleaner.instance(), moduleContext);
+        }
 
         final BidRequest bidRequest = applyActivityRestrictions(auctionRequestPayload.bidRequest(), invocationContext);
 
@@ -66,7 +85,6 @@ public Future<InvocationResult<AuctionRequestPayload>> call(AuctionRequestPayloa
                 invocationContext.auctionContext(),
                 properties.getTimeout());
 
-        final long callTargetingAPITimestamp = System.currentTimeMillis();
         return optableTargeting.getTargeting(properties, bidRequest, attributes, timeout)
                 .compose(targetingResult -> {
                     moduleContext.setOptableTargetingExecutionTime(
@@ -81,6 +99,10 @@ public Future<InvocationResult<AuctionRequestPayload>> call(AuctionRequestPayloa
                 });
     }
 
+    private boolean validateTargetingProperties(OptableTargetingProperties properties) {
+        return !StringUtils.isEmpty(properties.getOrigin()) && !StringUtils.isEmpty(properties.getTenant());
+    }
+
     private BidRequest applyActivityRestrictions(BidRequest bidRequest,
                                                  AuctionInvocationContext auctionInvocationContext) {
 

extra/modules/optable-targeting/src/test/java/org/prebid/server/hooks/modules/optable/targeting/v1/BaseOptableTest.java

@@ -224,17 +224,24 @@ protected String givenBodyFromFile(String fileName) {
     }
 
     protected OptableTargetingProperties givenOptableTargetingProperties(boolean enableCache) {
-        return givenOptableTargetingProperties("key", enableCache);
+        return givenOptableTargetingProperties("key", "accountId", "origin", enableCache);
     }
 
     protected OptableTargetingProperties givenOptableTargetingProperties(String key, boolean enableCache) {
+        return givenOptableTargetingProperties(key, "accountId", "origin", enableCache);
+    }
+
+    protected OptableTargetingProperties givenOptableTargetingProperties(String key,
+                                                                         String tenant,
+                                                                         String origin,
+                                                                         boolean enableCache) {
         final CacheProperties cacheProperties = new CacheProperties();
         cacheProperties.setEnabled(enableCache);
 
         final OptableTargetingProperties optableTargetingProperties = new OptableTargetingProperties();
         optableTargetingProperties.setApiEndpoint("endpoint");
-        optableTargetingProperties.setTenant("accountId");
-        optableTargetingProperties.setOrigin("origin");
+        optableTargetingProperties.setTenant(tenant);
+        optableTargetingProperties.setOrigin(origin);
         optableTargetingProperties.setApiKey(key);
         optableTargetingProperties.setPpidMapping(Map.of("c", "id"));
         optableTargetingProperties.setAdserverTargeting(true);

extra/modules/optable-targeting/src/test/java/org/prebid/server/hooks/modules/optable/targeting/v1/OptableTargetingProcessedAuctionRequestHookTest.java

@@ -14,6 +14,8 @@
 import org.prebid.server.auction.privacy.enforcement.mask.UserFpdActivityMask;
 import org.prebid.server.execution.timeout.Timeout;
 import org.prebid.server.hooks.execution.v1.auction.AuctionRequestPayloadImpl;
+import org.prebid.server.hooks.modules.optable.targeting.model.ModuleContext;
+import org.prebid.server.hooks.modules.optable.targeting.model.Status;
 import org.prebid.server.hooks.modules.optable.targeting.v1.core.ConfigResolver;
 import org.prebid.server.hooks.modules.optable.targeting.v1.core.OptableTargeting;
 import org.prebid.server.hooks.v1.InvocationAction;
@@ -61,7 +63,8 @@ public void setUp() {
         target = new OptableTargetingProcessedAuctionRequestHook(
                 configResolver,
                 optableTargeting,
-                userFpdActivityMask);
+                userFpdActivityMask,
+                0.01);
 
         when(invocationContext.accountConfig()).thenReturn(givenAccountConfig(true));
         when(invocationContext.auctionContext()).thenReturn(givenAuctionContext(activityInfrastructure, timeout));
@@ -128,6 +131,70 @@ public void shouldReturnResultWithUpdateActionWhenOptableTargetingReturnTargetin
         assertThat(bidRequest.getUser().getData().getFirst().getSegment().getFirst().getId()).isEqualTo("id");
     }
 
+    @Test
+    public void shouldReturnFailWhenOriginIsAbsentInAccountConfiguration() {
+        // given
+        configResolver = new ConfigResolver(
+                mapper,
+                jsonMerger,
+                givenOptableTargetingProperties("key", "tenant", null, false));
+        target = new OptableTargetingProcessedAuctionRequestHook(
+                configResolver,
+                optableTargeting,
+                userFpdActivityMask,
+                0.01);
+        when(invocationContext.accountConfig())
+                .thenReturn(givenAccountConfig("key", "tenant", null, true));
+
+        // when
+        final Future<InvocationResult<AuctionRequestPayload>> future = target.call(auctionRequestPayload,
+                invocationContext);
+
+        // then
+        assertThat(future).isNotNull();
+        assertThat(future.succeeded()).isTrue();
+
+        final InvocationResult<AuctionRequestPayload> result = future.result();
+        assertThat(result).isNotNull();
+        assertThat(result.status()).isEqualTo(InvocationStatus.success);
+        assertThat(result.action()).isEqualTo(InvocationAction.update);
+        assertThat((ModuleContext) result.moduleContext())
+                .extracting(it -> it.getEnrichRequestStatus().getStatus())
+                .isEqualTo(Status.FAIL);
+    }
+
+    @Test
+    public void shouldReturnFailWhenTenantIsAbsentInAccountConfiguration() {
+        // given
+        configResolver = new ConfigResolver(
+                mapper,
+                jsonMerger,
+                givenOptableTargetingProperties("key", null, "origin", false));
+        target = new OptableTargetingProcessedAuctionRequestHook(
+                configResolver,
+                optableTargeting,
+                userFpdActivityMask,
+                0.01);
+        when(invocationContext.accountConfig())
+                .thenReturn(givenAccountConfig("key", null, null, true));
+
+        // when
+        final Future<InvocationResult<AuctionRequestPayload>> future = target.call(auctionRequestPayload,
+                invocationContext);
+
+        // then
+        assertThat(future).isNotNull();
+        assertThat(future.succeeded()).isTrue();
+
+        final InvocationResult<AuctionRequestPayload> result = future.result();
+        assertThat(result).isNotNull();
+        assertThat(result.status()).isEqualTo(InvocationStatus.success);
+        assertThat(result.action()).isEqualTo(InvocationAction.update);
+        assertThat((ModuleContext) result.moduleContext())
+                .extracting(it -> it.getEnrichRequestStatus().getStatus())
+                .isEqualTo(Status.FAIL);
+    }
+
     @Test
     public void shouldReturnResultWithCleanedUpUserExtOptableTag() {
         // given
@@ -180,6 +247,10 @@ public void shouldReturnResultWithUpdateWhenOptableTargetingDoesntReturnResult()
     }
 
     private ObjectNode givenAccountConfig(boolean cacheEnabled) {
-        return mapper.valueToTree(givenOptableTargetingProperties(cacheEnabled));
+        return givenAccountConfig("key", "tenant", "origin", cacheEnabled);
+    }
+
+    private ObjectNode givenAccountConfig(String key, String tenant, String origin, boolean cacheEnabled) {
+        return mapper.valueToTree(givenOptableTargetingProperties(key, tenant, origin, cacheEnabled));
     }
 }