adservice add highcpu load ff

CHANGELOG.md

@@ -67,6 +67,8 @@ the release.
   ([#1462](https://github.com/open-telemetry/opentelemetry-demo/pull/1462))
 * [loadgenerator] added loadgeneratorFloodHomepage flagd
   ([#1486](https://github.com/open-telemetry/opentelemetry-demo/pull/1486))
+* [adservice] add adServiceHighCpu feature flag
+  ([#1510](https://github.com/open-telemetry/opentelemetry-demo/pull/1510))
 
 ## 1.8.0
 

src/adservice/src/main/java/oteldemo/AdService.java

@@ -35,6 +35,7 @@
 import oteldemo.Demo.AdRequest;
 import oteldemo.Demo.AdResponse;
 import oteldemo.problempattern.GarbageCollectionTrigger;
+import oteldemo.problempattern.CPULoad;
 import dev.openfeature.contrib.providers.flagd.FlagdOptions;
 import dev.openfeature.contrib.providers.flagd.FlagdProvider;
 import dev.openfeature.sdk.Client;
@@ -130,6 +131,7 @@ private static class AdServiceImpl extends oteldemo.AdServiceGrpc.AdServiceImplB
 
     private static final String ADSERVICE_FAILURE = "adServiceFailure";
     private static final String ADSERVICE_MANUAL_GC_FEATURE_FLAG = "adServiceManualGc";
+    private static final String ADSERVICE_HIGH_CPU_FEATURE_FLAG = "adServiceHighCpu";
 
     private AdServiceImpl() {}
 
@@ -143,6 +145,8 @@ private AdServiceImpl() {}
     @Override
     public void getAds(AdRequest req, StreamObserver<AdResponse> responseObserver) {
       AdService service = AdService.getInstance();
+      CPULoad cpuload = CPULoad.getInstance();
+      cpuload.execute(getFeatureFlagEnabled(ADSERVICE_HIGH_CPU_FEATURE_FLAG));
 
       // get the current span in context
       Span span = Span.current();

src/adservice/src/main/java/oteldemo/problempattern/CPULoad.java

@@ -0,0 +1,116 @@
+/*
+* Copyright The OpenTelemetry Authors
+* SPDX-License-Identifier: Apache-2.0
+*/
+package oteldemo.problempattern;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import io.grpc.ManagedChannelBuilder;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+/**
+ * This class is designed to simulate a high CPU load scenario.
+ * It contains methods to start and stop a specified number of worker threads designed to
+ * perform CPU-intensive calculations.
+ */
+public class CPULoad {
+    private static final Logger logger = LogManager.getLogger(CPULoad.class.getName());
+    private static final int THREAD_COUNT = 4;
+    private boolean running = false;
+    private final List<Logarithmizer> runningWorkers = new ArrayList<>();
+
+    private static CPULoad instance;
+
+    /**
+     * Singleton pattern to get the instance of CPULoad.
+     * @return The singleton instance of CPULoad.
+     */
+    public static CPULoad getInstance() {
+        if (instance == null) {
+            instance = new CPULoad();
+        }
+        return instance;
+    }
+
+    /**
+     * Starts or stops the CPU load generation based on the input parameter.
+     * If enabled, it launches worker threads. If disabled, it stops any running threads.
+     * 
+     * @param enabled Flag to start (true) or stop (false) the CPU load simulation.
+     */
+    public void execute(Boolean enabled) {
+        if (enabled) {
+            logger.info("High CPU-Load problempattern enabled");
+            if (!running) {
+                spawnLoadWorkers(THREAD_COUNT);
+                running = true;
+            }
+        } else {
+            running = false;
+            stopWorkers();
+        }
+    }
+
+    /**
+     * Creates and starts a specified number of Logarithmizer threads to simulate CPU load.
+     * 
+     * @param threadCount The number of threads to be started.
+     */
+    private void spawnLoadWorkers(int threadCount) {
+        synchronized(runningWorkers) {
+            for (int i = 0; i < threadCount; i++) {
+                Logarithmizer logarithmizer = new Logarithmizer();
+                Thread thread = new Thread(logarithmizer);
+                thread.setDaemon(true);
+                thread.start();
+                runningWorkers.add(logarithmizer);
+            }
+        }
+    }
+
+    /**
+     * Signals all running Logarithmizer threads to stop and clears the list of running workers.
+     */
+    private void stopWorkers() {
+        synchronized(runningWorkers) {
+            for (Logarithmizer logarithmizer : runningWorkers) {
+                logarithmizer.setShouldRun(false);
+            }
+            runningWorkers.clear();
+        }
+    }
+
+    /**
+     * Inner class representing a worker focused on calculating logarithms to consume CPU resources.
+     */
+    private static class Logarithmizer implements Runnable {
+
+        private volatile boolean shouldRun = true;
+
+        /**
+         * Continuously calculates the logarithm of the current system time until
+         * requested to stop.
+         */
+        @Override
+        public void run() {
+            while (shouldRun) {
+                Math.log(System.currentTimeMillis());
+            }
+        }
+
+        /**
+         * Sets the shouldRun flag to control whether this Logarithmizer should continue
+         * to run.
+         *
+         * @param shouldRun A boolean flag to continue (true) or stop (false) the logarithm computation.
+         */
+        public void setShouldRun(boolean shouldRun) {
+            this.shouldRun = shouldRun;
+       }
+    }
+}

src/flagd/demo.flagd.json

@@ -28,6 +28,15 @@
         },
         "defaultVariant": "off"
     },
+    "adServiceHighCpu": {
+      "description": "Triggers high cpu load in the ad service",
+      "state": "ENABLED",
+      "variants": {
+          "on": true,
+          "off": false
+        },
+        "defaultVariant": "off"
+    },
     "adServiceFailure": {
       "description": "Fail ad service",
       "state": "ENABLED",