adservice add highcpu load ff (#1510)

* adservice add highcpu load ff

This commit adds a new ff to the adservice. When enabled, the adservice uses an abnormal amout of CPU.

Should you want to demo cpu throtteling, you need to add cpu limits to the pod/container

* update changelog

---------

Co-authored-by: Juliano Costa <julianocosta89@outlook.com>

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",