argus-alm 0.15.10__tar.gz → 0.15.12__tar.gz

argus_alm-0.15.12/.github/workflows/call_jira_sync.yml

@@ -0,0 +1,42 @@
+name: Sync Jira Based on PR Events
+
+on:
+  pull_request_target:
+    types:
+      [opened, ready_for_review, review_requested, labeled, unlabeled, closed]
+
+permissions:
+  contents: read
+  pull-requests: write
+  issues: write
+
+jobs:
+  jira-sync-pr-opened:
+    if: github.event.action == 'opened'
+    uses: scylladb/github-automation/.github/workflows/main_jira_sync_pr_opened.yml@main
+    secrets:
+      caller_jira_auth: ${{ secrets.USER_AND_KEY_FOR_JIRA_AUTOMATION }}
+
+  jira-sync-in-review:
+    if: github.event.action == 'ready_for_review' || github.event.action == 'review_requested'
+    uses: scylladb/github-automation/.github/workflows/main_jira_sync_in_review.yml@main
+    secrets:
+      caller_jira_auth: ${{ secrets.USER_AND_KEY_FOR_JIRA_AUTOMATION }}
+
+  jira-sync-add-label:
+    if: github.event.action == 'labeled'
+    uses: scylladb/github-automation/.github/workflows/main_jira_sync_add_label.yml@main
+    secrets:
+      caller_jira_auth: ${{ secrets.USER_AND_KEY_FOR_JIRA_AUTOMATION }}
+
+  jira-status-remove-label:
+    if: github.event.action == 'unlabeled'
+    uses: scylladb/github-automation/.github/workflows/main_jira_sync_remove_label.yml@main
+    secrets:
+      caller_jira_auth: ${{ secrets.USER_AND_KEY_FOR_JIRA_AUTOMATION }}
+
+  jira-status-pr-closed:
+    if: github.event.action == 'closed'
+    uses: scylladb/github-automation/.github/workflows/main_jira_sync_pr_closed.yml@main
+    secrets:
+      caller_jira_auth: ${{ secrets.USER_AND_KEY_FOR_JIRA_AUTOMATION }}

argus_alm-0.15.12/.github/workflows/close_issue_for_scylla_employee.yml

@@ -0,0 +1,62 @@
+name: Close issues created by Scylla employees
+
+on:
+  issues:
+    types: [opened, reopened]
+
+permissions:
+  issues: write
+
+jobs:
+  comment-and-close:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Comment and close if author email is scylladb.com
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            const issue = context.payload.issue;
+            const actor = context.actor;
+
+            // Get user data (only public email is available)
+            const { data: user } = await github.rest.users.getByUsername({
+              username: actor,
+            });
+
+            const email = user.email || "";
+            console.log(`Actor: ${actor}, public email: ${email || "<none>"}`);
+
+            // Only continue if email exists and ends with @scylladb.com
+            if (!email || !email.toLowerCase().endsWith("@scylladb.com")) {
+              console.log("User is not a scylladb.com email (or email not public); skipping.");
+              return;
+            }
+
+            const owner = context.repo.owner;
+            const repo = context.repo.repo;
+            const issue_number = issue.number;
+
+            const body = "Issues in this repository are closed automatically. Scylla employees should use Jira to manage issues.\nPlease move this issue to Jira https://scylladb.atlassian.net/jira/software/c/projects/ARGUS/list";
+
+            // Add the comment
+            await github.rest.issues.createComment({
+              owner,
+              repo,
+              issue_number,
+              body,
+            });
+
+            console.log(`Comment added to #${issue_number}`);
+
+            // Close the issue
+            await github.rest.issues.update({
+              owner,
+              repo,
+              issue_number,
+              state: "closed",
+              state_reason: "not_planned"
+            });
+
+            console.log(`Issue #${issue_number} closed.`);

{argus_alm-0.15.10 → argus_alm-0.15.12}/.github/workflows/test.yml

@@ -29,7 +29,7 @@ jobs:
           python-version: '3.12'
 
       - name: Install project dependencies
-        run: uv sync --extra web-backend --extra dev
+        run: uv sync --extra web-backend --extra dev --extra ai
 
       - name: Verify Docker installation
         run: docker --version

{argus_alm-0.15.10 → argus_alm-0.15.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: argus-alm
-Version: 0.15.10
+Version: 0.15.12
 Summary: Argus
 Author-email: Alexey Kartashov <alexey.kartashov@scylladb.com>, Łukasz Sójka <lukasz.sojka@scylladb.com>
 License-Expression: Apache-2.0
@@ -11,13 +11,15 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.26.0
 Requires-Dist: click>=8.1.3
+Requires-Dist: lz4>=4.4.4
 Provides-Extra: web-backend
 Requires-Dist: PyYAML~=6.0.0; extra == "web-backend"
-Requires-Dist: scylla-driver>=3.26.8; extra == "web-backend"
+Requires-Dist: scylla-driver>=3.29.4; extra == "web-backend"
 Requires-Dist: Flask~=3.0.0; extra == "web-backend"
 Requires-Dist: Flask-WTF~=1.0.0; extra == "web-backend"
 Requires-Dist: Flask-Login~=0.5.0; extra == "web-backend"
 Requires-Dist: humanize~=3.13.1; extra == "web-backend"
+Requires-Dist: PyJWT[crypto]>=2.10.0; extra == "web-backend"
 Requires-Dist: python-magic~=0.4.24; extra == "web-backend"
 Requires-Dist: uwsgi~=2.0.20; extra == "web-backend"
 Requires-Dist: python-jenkins>=1.7.0; extra == "web-backend"
@@ -43,6 +45,8 @@ Requires-Dist: nox~=2025.5.1; extra == "dev"
 Requires-Dist: pytest-xdist~=3.7.0; extra == "dev"
 Requires-Dist: pytest-subtests~=0.14.1; extra == "dev"
 Requires-Dist: boto3-stubs~=1.38.9; extra == "dev"
+Provides-Extra: ai
+Requires-Dist: chromadb>=1.0.15; extra == "ai"
 Dynamic: license-file
 
 # Argus

{argus_alm-0.15.10 → argus_alm-0.15.12}/argus/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.15.10'
-__version_tuple__ = version_tuple = (0, 15, 10)
+__version__ = version = '0.15.12'
+__version_tuple__ = version_tuple = (0, 15, 12)
 
-__commit_id__ = commit_id = 'gfb79cf01d'
+__commit_id__ = commit_id = 'g11df55d0a'

{argus_alm-0.15.10 → argus_alm-0.15.12}/argus/client/sct/client.py

@@ -28,7 +28,9 @@ class ArgusSCTClient(ArgusClient):
         SUBMIT_EVENTS = "/sct/$id/events/submit"
         SUBMIT_EVENT = "/sct/$id/event/submit"
         SUBMIT_JUNIT_REPORT = "/sct/$id/junit/submit"
+        SUBMIT_STRESS_CMD = "/sct/$id//stress_cmd/submit"
         SUBMIT_EMAIL = "/testrun/report/email"
+        SUBMIT_CONFIG = "/$id/config/submit"
 
     def __init__(self, run_id: UUID, auth_token: str, base_url: str, api_version="v1", extra_headers: dict | None = None,
                  timeout: int = 60, max_retries: int = 3) -> None:
@@ -126,6 +128,22 @@ class ArgusSCTClient(ArgusClient):
         )
         self.check_response(response)
 
+    def add_stress_command(self, command: str, log_name: str, loader_name: str) -> None:
+        """
+            Submits stress command information to be viewed inside Argus.
+        """
+        response = self.post(
+            endpoint=self.Routes.SUBMIT_STRESS_CMD,
+            location_params={"id": str(self.run_id)},
+            body={
+                **self.generic_body,
+                "cmd": command,
+                "log_name": log_name,
+                "loader_name": loader_name,
+            }
+        )
+        self.check_response(response)
+
     def submit_screenshots(self, screenshot_links: list[str]) -> None:
         """
             Submits links to the screenshots from grafana, taken at the end of the test.
@@ -260,7 +278,8 @@ class ArgusSCTClient(ArgusClient):
         self.check_response(response)
 
     def submit_nemesis(self, name: str, class_name: str, start_time: int,
-                       target_name: str, target_ip: str, target_shards: int) -> None:
+                       target_name: str, target_ip: str, target_shards: int,
+                       description: str | None = None) -> None:
         """
             Submits a nemesis record. Should then be finalized by
             .finalize_nemesis method on nemesis completion.
@@ -277,6 +296,7 @@ class ArgusSCTClient(ArgusClient):
                     "node_name": target_name,
                     "node_ip": target_ip,
                     "node_shards": target_shards,
+                    "description": description,
                 }
             }
         )
@@ -334,3 +354,19 @@ class ArgusSCTClient(ArgusClient):
                 "content": str(base64.encodebytes(bytes(raw_content, encoding="utf-8")), encoding="utf-8")
             }
         )
+        self.check_response(response)
+
+    def sct_submit_config(self, name: str, content: str) -> None:
+        """
+            Submit a config file.
+        """
+        response = self.post(
+            endpoint=self.Routes.SUBMIT_CONFIG,
+            location_params={"id": str(self.run_id)},
+            body={
+                **self.generic_body,
+                "name": name,
+                "content": str(base64.encodebytes(bytes(content, encoding="utf-8")), encoding="utf-8")
+            }
+        )
+        self.check_response(response)

argus_alm-0.15.12/argusAI/README.md

@@ -0,0 +1,149 @@
+# Event Similarity Processor V2
+
+## Overview
+
+This directory contains the Event Similarity Processor V2 — the new system that generates and stores embeddings for SCT events. It supersedes the legacy `event_similarity_processor.py` that worked with the deprecated `sct_run` table, but for now both systems are allowed to run in parallel (see "Co‑existence with V1").
+
+## Architecture
+
+The processor follows a clean, decoupled flow:
+
+1. Event creation → SCT events are submitted via `SCTService.submit_event()`
+2. Queue → ERROR and CRITICAL events are added to `sct_unprocessed_events`
+3. Processing loop → `event_similarity_processor_v2.py` continuously reads from the queue
+4. Embedding generation → Message is sanitized, then embedded via the BGE‑Small‑EN model
+5. Storage → Embeddings are written into severity‑specific tables
+6. Cleanup → Processed events are removed from the queue
+
+## Database Tables
+
+### sct_unprocessed_events
+Tracks events that need embedding generation:
+- `run_id` (UUID, partition key)
+- `severity` (text, clustering key)
+- `ts` (timestamp, clustering key)
+
+### sct_error_event_embedding
+Stores ERROR event embeddings (separate table for performance):
+- `run_id` (UUID, partition key)
+- `ts` (timestamp, clustering key)
+- `embedding` (list<float>)
+
+### sct_critical_event_embedding
+Stores CRITICAL event embeddings (separate table for performance):
+- `run_id` (UUID, partition key)
+- `ts` (timestamp, clustering key)
+- `embedding` (list<float>)
+
+Note: Using separate tables for ERROR and CRITICAL events keeps similarity searches scoped to a single severity class and improves query performance by avoiding mixed‑severity comparisons.
+
+## Running the Processor
+
+### Standalone
+```bash
+cd argusAI
+PYTHONPATH=.. uv run event_similarity_processor_v2.py
+```
+
+### As a Service
+The processor runs in an infinite loop and every ~1s:
+- Reads up to 100 unprocessed events per batch
+- Routes embeddings to the table matching the event severity
+- Handles errors gracefully (logs and continues)
+- Can be stopped with Ctrl+C
+
+## Key Features
+
+### Severity‑specific storage
+- ERROR → `sct_error_event_embedding`
+- CRITICAL → `sct_critical_event_embedding`
+- Faster similarity searches within the same severity
+
+### Message sanitization
+Uses `MessageSanitizer` from `argusAI/utils/event_message_sanitizer.py` to:
+- Remove IPs, URLs, file paths
+- Normalize timestamps and memory addresses
+- Clean up stack traces and backtraces
+- Remove redundant/noisy details
+
+### Embedding model
+`BgeSmallEnEmbeddingModel` (BGE‑Small‑EN‑v1.5):
+- 384‑dimensional embeddings
+- Optimized for semantic similarity search
+- Same model family used by the legacy processor for consistency
+
+### Error handling
+- Event not found → logged and skipped
+- Empty message → logged and skipped
+- Sanitization failure → logged and removed from queue
+- Embedding failure → logged and removed from queue
+- Failures are removed from the queue to avoid infinite retries
+
+## Testing
+
+### Unit tests
+```bash
+PYTHONPATH=. uv run pytest argusAI
+```
+
+Covers initialization, single/batch processing, error handling, and shutdown behavior.
+
+### Integration tests
+```bash
+uv run pytest argus/backend/tests/sct_events/test_event_embedding_integration.py -v
+```
+
+Covers the end‑to‑end flow from event creation to storage, proper routing to severity tables, verifying that non‑ERROR/CRITICAL events don’t create queue entries, multi‑event processing, and error recovery.
+
+## Monitoring & Metrics
+
+Logging:
+- INFO: processing cycles, batch counts, startup/shutdown, table routing
+- DEBUG: per‑event processing, chosen table names
+- WARNING: missing events, empty messages
+- ERROR: processing/database failures
+
+Metrics:
+- `processed_count`: total successfully processed events
+- `error_count`: total errors encountered
+
+## Differences from V1
+
+Improvements in V2:
+1. Cleaner architecture: no Vector DB dependency for processing
+2. Better error handling: failures don’t block processing
+3. Simpler flow: queue → process → store
+4. Severity‑specific tables for similarity performance
+5. Comprehensive unit and integration tests
+
+What’s not included in V2:
+- Similarity search (removed from the processor itself)
+- ChromaDB collections (not required for embedding storage)
+- Historical event backfill (processes only new events)
+
+## Performance Benefits
+
+By separating ERROR and CRITICAL embeddings:
+- Faster similarity searches (smaller, severity‑scoped sets)
+- Better data locality
+- Reduced query complexity (no severity filters inside similarity search)
+- Improved scalability (per‑table tuning)
+
+## Configuration
+
+No dedicated config file is required for the processor itself. It uses the standard Argus configuration for database connectivity (e.g., ScyllaDB settings from your environment or YAML config such as `argus.yaml`/`argus.local.yaml`, depending on your deployment). The embedding model is auto‑downloaded to `~/.cache/chroma/onnx_models/`.
+
+## Co‑existence with V1 (temporary)
+
+- For now, both V1 (`event_similarity_processor.py`) and V2 (`event_similarity_processor_v2.py`) may run in parallel.
+- There is no data migration at this time; V1 will be disabled once the team fully moves to V2.
+- If you still need to run V1 locally for comparison or fallback:
+  ```bash
+  cd argusAI
+  PYTHONPATH=.. uv run event_similarity_processor.py
+  ```
+
+## Notes
+
+- Avoid mixing severities in similarity queries; use the dedicated tables for the best performance.
+- If you encounter repeated failures for the same event, verify the event content after sanitization and check connectivity to the database and model files.

argus_alm-0.15.12/argusAI/event_similarity_processor_v2.py

@@ -0,0 +1,237 @@
+"""
+Event Similarity Processor V2
+
+This module processes SCT events by:
+1. Reading unprocessed events from SCTUnprocessedEvent table
+2. Sanitizing event messages
+3. Generating embeddings using BGE-Small-EN model
+4. Storing embeddings in separate tables (sct_error_event_embedding or sct_critical_event_embedding)
+5. Removing processed events from unprocessed queue
+"""
+
+import logging
+import time
+from pathlib import Path
+from threading import Event
+from uuid import UUID
+from datetime import datetime
+
+from chromadb.utils.embedding_functions.onnx_mini_lm_l6_v2 import ONNXMiniLM_L6_V2
+
+from argus.backend.models.argus_ai import SCTCriticalEventEmbedding, SCTErrorEventEmbedding
+from argus.backend.plugins.sct.testrun import SCTUnprocessedEvent, SCTEvent
+from argus.backend.util.logsetup import setup_application_logging
+from argusAI.utils.scylla_connection import ScyllaConnection
+from argusAI.utils.event_message_sanitizer import MessageSanitizer
+
+LOGGER = logging.getLogger(__name__)
+SLEEP_INTERVAL = 1  # Sleep for 1 second between processing cycles
+
+
+class BgeSmallEnEmbeddingModel(ONNXMiniLM_L6_V2):
+    """
+    Compact English text embedding model by BAAI, released Sep 2023.
+    Trained on large-scale paired data with RetroMAE and contrastive learning.
+    Produces high-quality 384-dim embeddings, optimized for efficiency in semantic search, classification, and clustering.
+    """
+
+    MODEL_NAME: str = "bge-small-en-v1.5"
+    DOWNLOAD_PATH: Path = Path.home() / ".cache" / "chroma" / "onnx_models" / MODEL_NAME
+    EXTRACTED_FOLDER_NAME: str = "onnx"
+    ARCHIVE_FILENAME: str = "onnx.tar.gz"
+    MODEL_DOWNLOAD_URL: str = (
+        "https://scylla-qa-public.s3.us-east-1.amazonaws.com/ArgusAI/bge-small-en-v1.5/onnx.tar.gz"
+    )
+    _MODEL_SHA256: str = "e7d1743b0c08f55c687cff6af696683398682f9ab4fb3cad1be644ee5553a72d"
+
+
+class EventSimilarityProcessorV2:
+    """
+    Processes unprocessed SCT events by generating embeddings and storing them in severity-specific tables.
+    """
+
+    def __init__(self, stop_event: Event | None = None) -> None:
+        """
+        Initialize the processor with embedding model and sanitizer.
+
+        Args:
+            stop_event: Optional threading.Event to signal shutdown
+        """
+        self.embedding_model = BgeSmallEnEmbeddingModel()
+        self.sanitizer = MessageSanitizer()
+        self.stop_event = stop_event or Event()
+        self.db = ScyllaConnection()
+        self.processed_count = 0
+        self.error_count = 0
+        LOGGER.info("EventSimilarityProcessorV2 initialized")
+
+    def process_unprocessed_events(self) -> None:
+        """
+        Main processing loop that continuously reads and processes unprocessed events.
+        """
+        LOGGER.info("Starting event processing loop")
+
+        while not self.stop_event.is_set():
+            try:
+                batch_processed = self._process_batch()
+                if batch_processed == 0:
+                    # No events to process, sleep before next iteration
+                    time.sleep(SLEEP_INTERVAL)
+                else:
+                    LOGGER.info(f"Processed {batch_processed} events in this batch")
+            except Exception as e:
+                LOGGER.error(f"Error in processing loop: {e}", exc_info=True)
+                self.error_count += 1
+                time.sleep(SLEEP_INTERVAL)
+
+        LOGGER.info(f"Processing loop stopped. Total processed: {self.processed_count}, Errors: {self.error_count}")
+
+    def _process_batch(self, batch_size: int = 100) -> int:
+        """
+        Process a batch of unprocessed events.
+
+        Args:
+            batch_size: Maximum number of events to process in one batch
+
+        Returns:
+            Number of events processed in this batch
+        """
+        # Fetch unprocessed events using raw query
+        query = f"SELECT run_id, severity, ts FROM {SCTUnprocessedEvent.__table_name__} LIMIT {batch_size}"
+        try:
+            rows = self.db.execute(query)
+            unprocessed_events = list(rows)
+        except Exception as e:
+            LOGGER.error(f"Failed to fetch unprocessed events: {e}", exc_info=True)
+            return 0
+
+        if not unprocessed_events:
+            return 0
+
+        processed_in_batch = 0
+
+        for event_row in unprocessed_events:
+            try:
+                self._process_single_event(run_id=event_row.run_id, severity=event_row.severity, ts=event_row.ts)
+                processed_in_batch += 1
+                self.processed_count += 1
+            except Exception as e:
+                LOGGER.error(
+                    f"Failed to process event (run_id={event_row.run_id}, "
+                    f"severity={event_row.severity}, ts={event_row.ts}): {e}",
+                    exc_info=True,
+                )
+                self.error_count += 1
+                # Still delete the unprocessed event to avoid infinite retries
+                delete_query = (
+                    f"DELETE FROM {SCTUnprocessedEvent.__table_name__} WHERE run_id = ? AND severity = ? AND ts = ?"
+                )
+                self.db.execute(delete_query, (event_row.run_id, event_row.severity, event_row.ts))
+
+        return processed_in_batch
+
+    def _process_single_event(self, run_id: UUID, severity: str, ts: datetime) -> None:
+        """
+        Process a single event: read, sanitize, embed, store, and cleanup.
+
+        Args:
+            run_id: Test run UUID
+            severity: Event severity (ERROR or CRITICAL)
+            ts: Event timestamp
+
+        Raises:
+            Exception: If event not found or embedding generation fails
+        """
+        LOGGER.debug(f"Processing event: run_id={run_id}, severity={severity}, ts={ts}")
+
+        # Step 1: Read event message from SCTEvent table
+        try:
+            query = f"SELECT message FROM {SCTEvent.__table_name__} WHERE run_id = ? AND severity = ? AND ts = ?"
+            result = self.db.execute(query, (run_id, severity, ts))
+            event = result.one()
+            if not event:
+                raise ValueError("Event not found")
+        except Exception:
+            LOGGER.warning(f"Event not found in SCTEvent table: run_id={run_id}, severity={severity}, ts={ts}")
+            raise
+
+        message = event.message
+        if not message:
+            LOGGER.warning(f"Event has no message: run_id={run_id}, severity={severity}, ts={ts}")
+            raise ValueError("Event message is empty")
+
+        # Step 2: Sanitize event message
+        try:
+            sanitized_message = self.sanitizer.sanitize(run_id, message)
+        except Exception as e:
+            LOGGER.error(f"Failed to sanitize message for event (run_id={run_id}): {e}", exc_info=True)
+            raise
+
+        if not sanitized_message or not sanitized_message.strip():
+            LOGGER.warning(f"Sanitized message is empty for event: run_id={run_id}, severity={severity}, ts={ts}")
+            raise ValueError("Sanitized message is empty")
+
+        # Step 3: Generate embedding
+        try:
+            embeddings = self.embedding_model([sanitized_message])
+            if not embeddings or len(embeddings) == 0:
+                raise ValueError("Embedding generation returned empty result")
+            embedding = embeddings[0]
+        except Exception as e:
+            LOGGER.error(f"Failed to generate embedding for event (run_id={run_id}): {e}", exc_info=True)
+            raise
+
+        # Step 4: Store embedding in severity-specific table
+        try:
+            if severity == "ERROR":
+                table_name = SCTErrorEventEmbedding.__table_name__
+            elif severity == "CRITICAL":
+                table_name = SCTCriticalEventEmbedding.__table_name__
+            else:
+                raise ValueError(f"Unsupported severity: {severity}")
+
+            insert_query = f"INSERT INTO {table_name} (run_id, ts, embedding) VALUES (?, ?, ?)"
+            self.db.execute(insert_query, (run_id, ts, embedding))
+            LOGGER.debug(f"Stored embedding in {table_name} for event: run_id={run_id}, ts={ts}")
+        except Exception as e:
+            LOGGER.error(f"Failed to store embedding for event (run_id={run_id}): {e}", exc_info=True)
+            raise
+
+        # Step 5: Remove entry from unprocessed_events table
+        try:
+            delete_query = (
+                f"DELETE FROM {SCTUnprocessedEvent.__table_name__} WHERE run_id = ? AND severity = ? AND ts = ?"
+            )
+            self.db.execute(delete_query, (run_id, severity, ts))
+            LOGGER.debug(f"Removed unprocessed event: run_id={run_id}, severity={severity}, ts={ts}")
+        except Exception as e:
+            LOGGER.error(f"Failed to delete unprocessed event (run_id={run_id}): {e}", exc_info=True)
+            raise
+
+    def shutdown(self) -> None:
+        """Shutdown the processor and cleanup resources."""
+        self.stop_event.set()
+        self.db.shutdown()
+        LOGGER.info("EventSimilarityProcessorV2 shutdown complete")
+
+
+def main():
+    """Main entry point for the event similarity processor."""
+    setup_application_logging(log_level=logging.INFO)
+
+    LOGGER.info("Starting Event Similarity Processor V2...")
+
+    stop_event = Event()
+    processor = EventSimilarityProcessorV2(stop_event=stop_event)
+
+    try:
+        processor.process_unprocessed_events()
+    except KeyboardInterrupt:
+        LOGGER.info("Received keyboard interrupt, shutting down...")
+    finally:
+        processor.shutdown()
+        LOGGER.info("Event Similarity Processor V2 stopped")
+
+
+if __name__ == "__main__":
+    main()

{argus_alm-0.15.10 → argus_alm-0.15.12}/argusAI/utils/event_message_sanitizer.py

@@ -1,3 +1,4 @@
+import os
 import re
 from datetime import datetime
 
@@ -107,6 +108,7 @@ class MessageSanitizer:
             self.remove_special_chars,
             self.normalize_whitespace,
         ]
+        os.makedirs("logs", exist_ok=True)
         self.sanitized_messages_fp = open(
             "logs/sanitized_messages_" + datetime.now().strftime("%Y-%m-%d_%H-%M-%S") + ".log", "w"
         )

{argus_alm-0.15.10 → argus_alm-0.15.12}/argus_alm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: argus-alm
-Version: 0.15.10
+Version: 0.15.12
 Summary: Argus
 Author-email: Alexey Kartashov <alexey.kartashov@scylladb.com>, Łukasz Sójka <lukasz.sojka@scylladb.com>
 License-Expression: Apache-2.0
@@ -11,13 +11,15 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.26.0
 Requires-Dist: click>=8.1.3
+Requires-Dist: lz4>=4.4.4
 Provides-Extra: web-backend
 Requires-Dist: PyYAML~=6.0.0; extra == "web-backend"
-Requires-Dist: scylla-driver>=3.26.8; extra == "web-backend"
+Requires-Dist: scylla-driver>=3.29.4; extra == "web-backend"
 Requires-Dist: Flask~=3.0.0; extra == "web-backend"
 Requires-Dist: Flask-WTF~=1.0.0; extra == "web-backend"
 Requires-Dist: Flask-Login~=0.5.0; extra == "web-backend"
 Requires-Dist: humanize~=3.13.1; extra == "web-backend"
+Requires-Dist: PyJWT[crypto]>=2.10.0; extra == "web-backend"
 Requires-Dist: python-magic~=0.4.24; extra == "web-backend"
 Requires-Dist: uwsgi~=2.0.20; extra == "web-backend"
 Requires-Dist: python-jenkins>=1.7.0; extra == "web-backend"
@@ -43,6 +45,8 @@ Requires-Dist: nox~=2025.5.1; extra == "dev"
 Requires-Dist: pytest-xdist~=3.7.0; extra == "dev"
 Requires-Dist: pytest-subtests~=0.14.1; extra == "dev"
 Requires-Dist: boto3-stubs~=1.38.9; extra == "dev"
+Provides-Extra: ai
+Requires-Dist: chromadb>=1.0.15; extra == "ai"
 Dynamic: license-file
 
 # Argus