Merge remote-tracking branch 'upstream/main' into retain-float-format-docs

Author: gibber9809

components/clp-package-utils/clp_package_utils/scripts/stop_clp.py

@@ -34,10 +34,12 @@
 logger = logging.getLogger(__file__)
 
 
-def stop_running_container(container_name: str, already_exited_containers: List[str], force: bool):
+def stop_running_container(
+    container_name: str, already_exited_containers: List[str], force: bool, timeout: int = 10
+):
     if is_container_running(container_name):
         logger.info(f"Stopping {container_name}...")
-        cmd = ["docker", "stop", container_name]
+        cmd = ["docker", "stop", "--timeout", str(timeout), container_name]
         subprocess.run(cmd, stdout=subprocess.DEVNULL, check=True)
 
         logger.info(f"Removing {container_name}...")
@@ -148,9 +150,6 @@ def main(argv):
         if target in (ALL_TARGET_NAME, QUERY_WORKER_COMPONENT_NAME):
             container_name = f"clp-{QUERY_WORKER_COMPONENT_NAME}-{instance_id}"
             stop_running_container(container_name, already_exited_containers, force)
-        if target in (ALL_TARGET_NAME, COMPRESSION_WORKER_COMPONENT_NAME):
-            container_name = f"clp-{COMPRESSION_WORKER_COMPONENT_NAME}-{instance_id}"
-            stop_running_container(container_name, already_exited_containers, force)
         if target in (ALL_TARGET_NAME, CONTROLLER_TARGET_NAME, QUERY_SCHEDULER_COMPONENT_NAME):
             container_name = f"clp-{QUERY_SCHEDULER_COMPONENT_NAME}-{instance_id}"
             stop_running_container(container_name, already_exited_containers, force)
@@ -164,11 +163,14 @@ def main(argv):
             COMPRESSION_SCHEDULER_COMPONENT_NAME,
         ):
             container_name = f"clp-{COMPRESSION_SCHEDULER_COMPONENT_NAME}-{instance_id}"
-            stop_running_container(container_name, already_exited_containers, force)
+            stop_running_container(container_name, already_exited_containers, force, timeout=300)
 
             container_config_file_path = logs_dir / f"{container_name}.yml"
             if container_config_file_path.exists():
                 container_config_file_path.unlink()
+        if target in (ALL_TARGET_NAME, COMPRESSION_WORKER_COMPONENT_NAME):
+            container_name = f"clp-{COMPRESSION_WORKER_COMPONENT_NAME}-{instance_id}"
+            stop_running_container(container_name, already_exited_containers, force, timeout=60)
         if target in (ALL_TARGET_NAME, CONTROLLER_TARGET_NAME, REDIS_COMPONENT_NAME):
             container_name = f"clp-{REDIS_COMPONENT_NAME}-{instance_id}"
             stop_running_container(container_name, already_exited_containers, force)

components/job-orchestration/job_orchestration/executor/compress/compression_task.py

@@ -6,6 +6,7 @@
 from contextlib import closing
 from typing import Any, Dict, List, Optional, Tuple
 
+from celery import signals
 from celery.app.task import Task
 from celery.utils.log import get_task_logger
 from clp_py_utils.clp_config import (
@@ -523,6 +524,11 @@ def run_clp(
         return CompressionTaskStatus.FAILED, worker_output
 
 
+@signals.worker_shutdown.connect
+def worker_shutdown_handler(signal=None, sender=None, **kwargs):
+    logger.info("Shutdown signal received.")
+
+
 @app.task(bind=True)
 def compress(
     self: Task,

components/job-orchestration/job_orchestration/scheduler/compress/compression_scheduler.py

@@ -2,6 +2,7 @@
 import datetime
 import logging
 import os
+import signal
 import sys
 import time
 from contextlib import closing
@@ -55,6 +56,14 @@
 
 scheduled_jobs = {}
 
+received_sigterm = False
+
+
+def sigterm_handler(signal_number, frame):
+    global received_sigterm
+    received_sigterm = True
+    logger.info("Received SIGTERM.")
+
 
 def fetch_new_jobs(db_cursor):
     db_cursor.execute(
@@ -451,6 +460,10 @@ def poll_running_jobs(db_conn, db_cursor):
     for job_id in jobs_to_delete:
         del scheduled_jobs[job_id]
 
+    if received_sigterm and 0 == len(scheduled_jobs):
+        logger.info("Recieved SIGTERM and there're no more running jobs. Exiting.")
+        sys.exit(0)
+
 
 def main(argv):
     args_parser = argparse.ArgumentParser()
@@ -466,6 +479,9 @@ def main(argv):
     # Update logging level based on config
     set_logging_level(logger, os.getenv("CLP_LOGGING_LEVEL"))
 
+    # Register the SIGTERM handler
+    signal.signal(signal.SIGTERM, sigterm_handler)
+
     # Load configuration
     config_path = Path(args.config)
     try:
@@ -500,16 +516,17 @@ def main(argv):
         # Start Job Processing Loop
         while True:
             try:
-                search_and_schedule_new_tasks(
-                    clp_config,
-                    db_conn,
-                    db_cursor,
-                    clp_metadata_db_connection_config,
-                )
+                if not received_sigterm:
+                    search_and_schedule_new_tasks(
+                        clp_config,
+                        db_conn,
+                        db_cursor,
+                        clp_metadata_db_connection_config,
+                    )
                 poll_running_jobs(db_conn, db_cursor)
                 time.sleep(clp_config.compression_scheduler.jobs_poll_delay)
             except KeyboardInterrupt:
-                logger.info("Gracefully shutting down")
+                logger.info("Forcefully shutting down")
                 return -1
             except Exception:
                 logger.exception(f"Error in scheduling.")

components/webui/client/package.json

@@ -25,7 +25,7 @@
     "@webui/common": "*",
     "antd": "^5.24.5",
     "antlr4": "^4.13.2",
-    "axios": "^1.7.9",
+    "axios": "^1.12.2",
     "chart.js": "^4.4.9",
     "chartjs-adapter-dayjs-4": "^1.0.4",
     "chartjs-plugin-zoom": "^2.2.0",

components/webui/package-lock.json

@@ -33,27 +33,60 @@ Using Presto with CLP requires:
 
 1. Follow the [quick-start](quick-start/index.md) guide to download and extract the CLP package,
    but don't start the package just yet.
-2. Before starting the package, update the package's config as follows:
+2. Before starting the package, update the package's config file (`etc/clp-config.yml`) as follows:
 
-    * Open `etc/clp-config.yml` located within the package.
-    * Uncomment the `database` section.
-    * Change `database.host` value to a non-localhost hostname/IP.
-    * After the change, the `database` section should look something like this:
+    * Set the `package.query_engine` key to `"presto"`.
 
       ```yaml
-      database:
-        type: "mariadb"  # "mariadb" or "mysql"
-        host: "<new-IP-address>"
-        port: 3306
-        name: "clp-db"
+      package:
+        storage_engine: "clp-s"
+        query_engine: "presto"
       ```
 
-    :::{note}
-    This change is necessary since the Presto containers run on a Docker network, whereas CLP's
-    database runs on the host network. So `localhost` refers to two different entities in those
-    networks. This limitation will be addressed in the future when we unify Presto and CLP's
-    deployment infrastructure.
-    :::
+    * Set the `database.host` key to a non-localhost hostname/IP.
+
+      ```yaml
+        database:
+        #  type: "mariadb"
+          host: "<non-local-ip-address>"
+        #  port: 3306
+        #  name: "clp-db"
+      ```
+
+      :::{note}
+      This change is necessary because the Presto containers run on a Docker network, and CLP's
+      database runs on the host network. `localhost` will refer to a different entity in each of
+      those contexts. This limitation will be addressed in the future when we unify Presto and CLP's
+      deployment infrastructure.
+      :::
+
+    * Set the `results_cache.retention_period` key to `null` since the CLP + Presto integration
+      doesn't yet support garbage collection.
+
+      ```yaml
+      results_cache:
+      #  host: "localhost"
+      #  port: 27017
+      #  db_name: "clp-query-results"
+      #  stream_collection_name: "stream-files"
+      #
+      #  # Retention period for search results, in minutes. Set to null to disable automatic deletion.
+        retention_period: null
+      ```
+
+    * Update the `presto` key with the host and port of the Presto cluster. If you follow the
+      [Setting up Presto](#setting-up-presto) section, the host is `localhost` and the port is
+      `8889`.
+
+      ```yaml
+      presto:
+        host: "<ip-address>"
+        port: <port>
+      ```
+
+      :::{note}
+      Presto doesn't need to be running before you start CLP.
+      :::
 
 3. If you'd like to store your compressed logs on S3, follow the
    [using object storage](guides-using-object-storage/index.md) guide.
@@ -115,7 +148,7 @@ Using Presto with CLP requires:
 5. Start a Presto cluster by running:
 
     ```bash
-    docker compose up
+    docker compose up --detach
     ```
 
     * To use more than one Presto worker, you can use the `--scale` option as follows:
@@ -128,24 +161,22 @@ Using Presto with CLP requires:
 
 ### Stopping the Presto cluster
 
-To stop the Presto cluster, use CTRL + C.
+To stop the Presto cluster:
+
+```bash
+docker compose stop
+```
 
 To clean up the Presto cluster entirely:
 
 ```bash
-docker compose rm
+docker compose down
 ```
 
 ## Querying your logs through Presto
 
-To query your logs through Presto, you can use the Presto CLI:
-
-```bash
-docker compose exec presto-coordinator \
-  presto-cli \
-    --catalog clp \
-    --schema default
-```
+You can query your compressed logs in your browser from [CLP's UI](#querying-from-clps-ui), or
+from the command line using the [Presto CLI](#querying-from-the-presto-cli).
 
 Each dataset in CLP shows up as a table in Presto. To show all available datasets:
 
@@ -179,6 +210,26 @@ contain the field `foo.bar`, you can query it using:
 SELECT foo.bar FROM default LIMIT 1;
 ```
 
+### Querying from CLP's UI
+
+CLP's UI should be available at [http://localhost:4000](http://localhost:4000) (if you changed
+`webui.host` or `webui.port` in `etc/clp-config.yml`, use the new values).
+
+:::{note}
+The UI can only run one query at a time, and queries must not end with a `;`.
+:::
+
+### Querying from the Presto CLI
+
+To access the Presto CLI, navigate to the `tools/deployment/presto-clp` directory and run:
+
+```bash
+docker compose exec presto-coordinator \
+  presto-cli \
+    --catalog clp \
+    --schema default
+```
+
 ## Limitations
 
 The Presto CLP integration has the following limitations at present: