vectorwave 0.1.4__tar.gz → 0.1.5__tar.gz

{vectorwave-0.1.4/src/vectorwave.egg-info → vectorwave-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectorwave
-Version: 0.1.4
+Version: 0.1.5
 Summary: VectorWave: Seamless Auto-Vectorization Framework
 Author-email: junyeonggim <junyeonggim5@gmail.com>
 License-Expression: MIT
@@ -20,6 +20,7 @@ License-File: NOTICE
 Requires-Dist: weaviate-client>=4.0.0
 Requires-Dist: pydantic-settings>=2.0.0
 Requires-Dist: sentence-transformers
+Requires-Dist: requests
 Dynamic: license-file
 
 
@@ -395,7 +396,6 @@ def other_function():
     pass
 ```
 
-**Tag Merging and Validation Rules**
 
 1.  **Validation (Important):** Tags (global or function-specific) will **only** be saved to Weaviate if their key (e.g., `run_id`, `team`, `priority`) was first defined in the `.weaviate_properties` file (Step 1). Tags not defined in the schema are **ignored**, and a warning is logged at startup.
 
@@ -408,6 +408,34 @@ def other_function():
 
 -----
 
+### 🚀 Real-time Error Alerting (Webhook)
+
+Beyond just logging, `VectorWave` can send **real-time notifications via webhook** the instant an error occurs. This functionality is built directly into the tracer and can be activated simply by updating your `.env` file.
+
+**How it Works:**
+1.  An exception is raised within a function decorated by `@trace_span` or `@vectorize`.
+2.  The tracer catches the exception in its `except` block and immediately calls the `alerter` object.
+3.  The alerter reads the `.env` configuration and uses the `WebhookAlerter` to dispatch the error details to your specified URL.
+4.  The notification is optimized for **Discord Embeds**, sending a rich report including the error code, trace ID, captured attributes (`user_id`, etc.), and the full stack trace.
+
+**How to Enable:**
+Add the following two variables to your `test_ex/.env` file (or environment variables):
+
+```ini
+# .env file
+
+# 1. Set the alerter strategy to 'webhook'. (Default: "none")
+ALERTER_STRATEGY="webhook"
+
+# 2. Provide your webhook URL from Discord, Slack, etc.
+ALERTER_WEBHOOK_URL="[https://discord.com/api/webhooks/YOUR_HOOK_ID/](https://discord.com/api/webhooks/YOUR_HOOK_ID/)..."
+With just these two lines, running test_ex/example.py will now instantly send a Discord alert when the CustomValueError is raised.
+
+Extensibility (Strategy Pattern): The alerting system is built on a Strategy Pattern. You can easily extend it by implementing the BaseAlerter interface to support other channels like email, PagerDuty, or more.
+
+**Tag Merging and Validation Rules**
+```
+
 ## 🤝 Contributing
 
 Bug reports, feature requests, and code contributions are all welcome. For details, please see [CONTRIBUTING.md](https://www.google.com/search?q=httpsS://www.google.com/search%3Fq%3DCONTRIBUTING.md).

{vectorwave-0.1.4 → vectorwave-0.1.5}/Readme.md

@@ -371,7 +371,6 @@ def other_function():
     pass
 ```
 
-**Tag Merging and Validation Rules**
 
 1.  **Validation (Important):** Tags (global or function-specific) will **only** be saved to Weaviate if their key (e.g., `run_id`, `team`, `priority`) was first defined in the `.weaviate_properties` file (Step 1). Tags not defined in the schema are **ignored**, and a warning is logged at startup.
 
@@ -384,6 +383,34 @@ def other_function():
 
 -----
 
+### 🚀 Real-time Error Alerting (Webhook)
+
+Beyond just logging, `VectorWave` can send **real-time notifications via webhook** the instant an error occurs. This functionality is built directly into the tracer and can be activated simply by updating your `.env` file.
+
+**How it Works:**
+1.  An exception is raised within a function decorated by `@trace_span` or `@vectorize`.
+2.  The tracer catches the exception in its `except` block and immediately calls the `alerter` object.
+3.  The alerter reads the `.env` configuration and uses the `WebhookAlerter` to dispatch the error details to your specified URL.
+4.  The notification is optimized for **Discord Embeds**, sending a rich report including the error code, trace ID, captured attributes (`user_id`, etc.), and the full stack trace.
+
+**How to Enable:**
+Add the following two variables to your `test_ex/.env` file (or environment variables):
+
+```ini
+# .env file
+
+# 1. Set the alerter strategy to 'webhook'. (Default: "none")
+ALERTER_STRATEGY="webhook"
+
+# 2. Provide your webhook URL from Discord, Slack, etc.
+ALERTER_WEBHOOK_URL="[https://discord.com/api/webhooks/YOUR_HOOK_ID/](https://discord.com/api/webhooks/YOUR_HOOK_ID/)..."
+With just these two lines, running test_ex/example.py will now instantly send a Discord alert when the CustomValueError is raised.
+
+Extensibility (Strategy Pattern): The alerting system is built on a Strategy Pattern. You can easily extend it by implementing the BaseAlerter interface to support other channels like email, PagerDuty, or more.
+
+**Tag Merging and Validation Rules**
+```
+
 ## 🤝 Contributing
 
 Bug reports, feature requests, and code contributions are all welcome. For details, please see [CONTRIBUTING.md](https://www.google.com/search?q=httpsS://www.google.com/search%3Fq%3DCONTRIBUTING.md).

{vectorwave-0.1.4 → vectorwave-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vectorwave"
-version = "0.1.4"
+version = "0.1.5"
 authors = [
     { name = "junyeonggim", email = "junyeonggim5@gmail.com" },
 ]
@@ -26,7 +26,8 @@ classifiers = [
 dependencies = [
     "weaviate-client>=4.0.0",
     "pydantic-settings>=2.0.0",
-    "sentence-transformers"
+    "sentence-transformers",
+    "requests"
 ]
 
 [project.urls]

vectorwave-0.1.5/src/tests/monitoring/alert/test_alerter.py

@@ -0,0 +1,70 @@
+from unittest.mock import MagicMock, patch
+
+from vectorwave.monitoring.alert.factory import get_alerter
+from vectorwave.monitoring.alert.null_alerter import NullAlerter
+from vectorwave.monitoring.alert.webhook_alerter import WebhookAlerter
+from vectorwave.models.db_config import WeaviateSettings
+
+@patch('vectorwave.monitoring.alert.factory.get_weaviate_settings')
+def test_get_alerter_returns_null_alerter_by_default(mock_get_settings):
+    """
+    Case 1: When .env settings are missing or ALERTER_STRATEGY="none"
+    - Should return NullAlerter.
+    """
+    # 1. Arrange
+    # Clear lru_cache to bypass caching
+    get_alerter.cache_clear()
+
+    # Mock default settings (strategy="none")
+    mock_get_settings.return_value = WeaviateSettings()
+
+    # 2. Act
+    alerter = get_alerter()
+
+    # 3. Assert
+    assert isinstance(alerter, NullAlerter)
+
+@patch('vectorwave.monitoring.alert.factory.get_weaviate_settings')
+def test_get_alerter_returns_webhook_alerter_when_configured(mock_get_settings):
+    """
+    Case 2: When ALERTER_STRATEGY="webhook" and URL is provided
+    - Should return WebhookAlerter.
+    """
+    # 1. Arrange
+    get_alerter.cache_clear()
+
+    # Mock settings object with webhook strategy and URL
+    settings = WeaviateSettings(
+        ALERTER_STRATEGY="webhook",
+        ALERTER_WEBHOOK_URL="https://test.webhook.url/..."
+    )
+    mock_get_settings.return_value = settings
+
+    # 2. Act
+    alerter = get_alerter()
+
+    # 3. Assert
+    assert isinstance(alerter, WebhookAlerter)
+    assert alerter.url == "https://test.webhook.url/..."
+
+@patch('vectorwave.monitoring.alert.factory.get_weaviate_settings')
+def test_get_alerter_returns_null_alerter_if_webhook_url_missing(mock_get_settings):
+    """
+    Case 3: When ALERTER_STRATEGY="webhook" but URL is missing
+    - Should log a warning and return NullAlerter.
+    """
+    # 1. Arrange
+    get_alerter.cache_clear()
+
+    # Mock settings with missing URL
+    settings = WeaviateSettings(
+        ALERTER_STRATEGY="webhook",
+        ALERTER_WEBHOOK_URL=None # URL is missing
+    )
+    mock_get_settings.return_value = settings
+
+    # 2. Act
+    alerter = get_alerter()
+
+    # 3. Assert
+    assert isinstance(alerter, NullAlerter)

{vectorwave-0.1.4 → vectorwave-0.1.5}/src/tests/monitoring/test_async_trace.py

@@ -23,6 +23,7 @@ async def test_trace_root_and_span_async_success(mock_tracer_deps):
     - ContextVar (trace_id) must be correctly propagated across 'await' boundaries
     '''
     mock_batch = mock_tracer_deps["batch"]
+    mock_alerter = mock_tracer_deps["alerter"]
 
     @trace_span(attributes_to_capture=['x'])
     async def my_async_inner_span(x):
@@ -37,6 +38,7 @@ async def test_trace_root_and_span_async_success(mock_tracer_deps):
         return result
 
     mock_batch.reset_mock()
+    mock_alerter.reset_mock()
 
     # --- Execution ---
     result = await my_async_workflow_root()
@@ -47,6 +49,8 @@ async def test_trace_root_and_span_async_success(mock_tracer_deps):
     # 2 calls expected: 1 (inner_span) + 1 (workflow_root)
     assert mock_batch.add_object.call_count == 2
 
+    mock_alerter.notify.assert_not_called()
+
     call_args_list = mock_batch.add_object.call_args_list
     props_map = {
         call.kwargs["properties"]["function_name"]: call.kwargs["properties"]
@@ -80,9 +84,12 @@ async def test_trace_span_async_failure(mock_tracer_deps):
     Case 2: Async span failure test
     '''
     mock_batch = mock_tracer_deps["batch"]
+    mock_alerter = mock_tracer_deps["alerter"]
 
     class AsyncTestError(Exception):
-        pass
+        @property
+        def error_code(self):
+            return "ASYNC_TEST_FAILURE"
 
     @trace_span
     async def my_failing_async_span():
@@ -97,6 +104,20 @@ async def test_trace_span_async_failure(mock_tracer_deps):
     with pytest.raises(AsyncTestError, match="Async failure test"):
         await my_async_workflow_fail()
 
+    mock_alerter.notify.assert_called_once()
+    alert_props = mock_alerter.notify.call_args.args[0]
+
+    assert alert_props["status"] == "ERROR"
+    assert "AsyncTestError: Async failure test" in alert_props["error_message"]
+    assert alert_props["function_name"] == "my_failing_async_span"
+    assert alert_props["error_code"] == "ASYNC_TEST_FAILURE"
+
+    mock_batch.add_object.assert_called_once()
+    db_props = mock_batch.add_object.call_args.kwargs["properties"]
+
+    assert db_props == alert_props
+    assert db_props["span_id"] == alert_props["span_id"]
+
     # --- Verification (Log) ---
     # Check if the failed span log was recorded
     failing_span_props = None
@@ -116,6 +137,7 @@ async def test_span_without_root_async_does_nothing(mock_tracer_deps):
     Case 3: Async span called without a root (@trace_root) should not be logged
     '''
     mock_batch = mock_tracer_deps["batch"]
+    mock_alerter = mock_tracer_deps["alerter"]
 
     @trace_span
     async def my_lonely_async_span():
@@ -126,6 +148,7 @@ async def test_span_without_root_async_does_nothing(mock_tracer_deps):
 
     assert result == "lonely_result"
     mock_batch.add_object.assert_not_called()
+    mock_alerter.notify.assert_not_called()
 
 
 # ==================================

{vectorwave-0.1.4 → vectorwave-0.1.5}/src/tests/monitoring/test_tracer.py

@@ -10,6 +10,7 @@ from vectorwave.batch.batch import get_batch_manager as real_get_batch_manager
 from vectorwave.database.db import get_cached_client as real_get_cached_client
 from vectorwave.models.db_config import get_weaviate_settings as real_get_settings
 from vectorwave.monitoring.tracer import TraceCollector, current_tracer_var
+from vectorwave.monitoring.alert.base import BaseAlerter
 
 # Module paths to mock (adjust to your project structure if needed)
 TRACER_MODULE_PATH = "vectorwave.monitoring.tracer"
@@ -42,12 +43,17 @@ def mock_tracer_deps(monkeypatch):
     )
     mock_get_settings = MagicMock(return_value=mock_settings)
 
+    mock_alerter_instance = MagicMock(spec=BaseAlerter)
+    mock_alerter_instance.notify = MagicMock()
+    mock_get_alerter = MagicMock(return_value=mock_alerter_instance)
+
     mock_client = MagicMock()
     mock_get_client = MagicMock(return_value=mock_client)
 
     # --- Patch dependencies for tracer.py ---
     monkeypatch.setattr(f"{TRACER_MODULE_PATH}.get_batch_manager", mock_get_batch_manager)
     monkeypatch.setattr(f"{TRACER_MODULE_PATH}.get_weaviate_settings", mock_get_settings)
+    monkeypatch.setattr(f"{TRACER_MODULE_PATH}.get_alerter", mock_get_alerter)
 
     # Patch dependencies inside batch.py to prevent BatchManager init failure
     monkeypatch.setattr(f"{BATCH_MODULE_PATH}.get_weaviate_client", mock_get_client)
@@ -60,7 +66,8 @@ def mock_tracer_deps(monkeypatch):
 
     return {
         "batch": mock_batch_instance,
-        "settings": mock_settings
+        "settings": mock_settings,
+        "alerter": mock_alerter_instance
     }
 
 
@@ -69,6 +76,7 @@ def test_trace_root_and_span_success(mock_tracer_deps):
     Case 1: Success (Root + Span) - The span should be recorded successfully.
     """
     mock_batch = mock_tracer_deps["batch"]
+    mock_alerter = mock_tracer_deps["alerter"]
 
     @trace_span
     def my_inner_span(x):
@@ -84,6 +92,7 @@ def test_trace_root_and_span_success(mock_tracer_deps):
     # --- Assert ---
     assert result == "result: 10"
     mock_batch.add_object.assert_called_once()
+    mock_alerter.notify.assert_not_called()
 
     args, kwargs = mock_batch.add_object.call_args
     props = kwargs["properties"]
@@ -103,6 +112,7 @@ def test_trace_span_failure(mock_tracer_deps):
     Case 2: Failure (Root + Failing Span) - The span should be recorded with an ERROR status.
     """
     mock_batch = mock_tracer_deps["batch"]
+    mock_alerter = mock_tracer_deps["alerter"]
 
     @trace_span
     def my_failing_span():
@@ -118,10 +128,21 @@ def test_trace_span_failure(mock_tracer_deps):
 
     # --- Assert (Log) ---
     mock_batch.add_object.assert_called_once()
+    db_props = mock_batch.add_object.call_args.kwargs["properties"]
+    assert db_props["status"] == "ERROR"
+    assert "ValueError: This is a test error" in db_props["error_message"]
+    assert db_props["error_code"] == "INVALID_INPUT"
+
+    mock_alerter.notify.assert_called_once()
+    alert_props = mock_alerter.notify.call_args.args[0]
 
     args, kwargs = mock_batch.add_object.call_args
     props = kwargs["properties"]
 
+
+    assert alert_props == db_props
+    assert alert_props["status"] == "ERROR"
+    assert alert_props["error_code"] == "INVALID_INPUT"
     assert props["status"] == "ERROR"
     assert "ValueError: This is a test error" in props["error_message"]
     assert kwargs["properties"]["error_code"] == "INVALID_INPUT"

vectorwave-0.1.5/src/tests/search/test_execution_search.py

@@ -0,0 +1,120 @@
+from datetime import datetime, timezone, timedelta
+from unittest.mock import MagicMock, patch
+
+import pytest
+from vectorwave.search.execution_search import (
+    find_executions,
+    find_recent_errors,
+    find_slowest_executions,
+    find_by_trace_id
+)
+
+
+@pytest.fixture
+def mock_low_level_search(monkeypatch):
+    """
+    Mocks 'vectorwave.database.db_search.search_executions'
+    Used when testing the find_executions function.
+    """
+    mock = MagicMock(return_value=["dummy_log_data"])
+    monkeypatch.setattr("vectorwave.search.execution_search.search_executions", mock)
+    return mock
+
+
+def test_find_executions(mock_low_level_search):
+    """
+    Tests if find_executions correctly passes arguments (dict) to the low-level function.
+    """
+    filters_dict = {"status": "OK"}  # Use dict
+
+    find_executions(
+        filters=filters_dict,
+        limit=5,
+        sort_by="duration_ms",
+        sort_ascending=True
+    )
+
+    # Check if the low-level search_executions function was called with the correct arguments
+    mock_low_level_search.assert_called_once_with(
+        filters=filters_dict,  # Check if dict was passed
+        limit=5,
+        sort_by="duration_ms",
+        sort_ascending=True
+    )
+
+
+# --- Setup for test_find_recent_errors ---
+mock_now = datetime(2025, 1, 1, 12, 0, 0, tzinfo=timezone.utc)
+expected_time_limit_iso = (mock_now - timedelta(minutes=10)).isoformat()
+
+# Mock error logs returned by the DB
+mock_db_errors = [
+    {"timestamp_utc": (mock_now - timedelta(minutes=1)).isoformat(), "error_code": "INVALID_INPUT"},
+    {"timestamp_utc": (mock_now - timedelta(minutes=2)).isoformat(), "error_code": "TIMEOUT"},
+    {"timestamp_utc": (mock_now - timedelta(minutes=15)).isoformat(), "error_code": "INVALID_INPUT"},  # Too old
+]
+
+
+# [Core Fix] Create mock datetime class
+# Replaces the datetime.datetime class itself.
+MockDateTime = MagicMock()
+# Set .now() to return a fixed time (mock_now) when called
+MockDateTime.now = MagicMock(return_value=mock_now)
+# Set .fromisoformat() to call the real datetime.fromisoformat function
+# (If this is omitted, a TypeError occurs in the log_time <= time_limit comparison)
+MockDateTime.fromisoformat = MagicMock(side_effect=datetime.fromisoformat)
+
+
+@patch('vectorwave.search.execution_search.datetime', MockDateTime)
+@patch('vectorwave.search.execution_search.find_executions', MagicMock(return_value=mock_db_errors))
+def test_find_recent_errors():
+    """
+    Tests if find_recent_errors (including manual filtering) works correctly.
+    """
+    # 1. Run test
+    result = find_recent_errors(minutes_ago=10, error_codes=["INVALID_INPUT"])
+
+    # 2. Verify result (if manual filtering worked correctly)
+    assert len(result) == 1  # Logs from 15 minutes ago should be filtered out
+    assert result[0]["error_code"] == "INVALID_INPUT"
+
+
+@patch('vectorwave.search.execution_search.find_executions')
+def test_find_slowest_executions(mock_find_executions):
+    """
+    Tests if find_slowest_executions sorts correctly by 'duration_ms'.
+    """
+    find_slowest_executions(limit=3, min_duration_ms=100.5)
+
+    call_args = mock_find_executions.call_args
+
+    # [Fix] Check if filters_arg is a dict (or None)
+    filters_arg = call_args.kwargs['filters']
+    assert (filters_arg is None) or isinstance(filters_arg, dict)
+
+    # 2. Verify sort order
+    assert call_args.kwargs['sort_by'] == 'duration_ms'
+    assert call_args.kwargs['sort_ascending'] == False
+    assert call_args.kwargs['limit'] == 3
+
+
+@patch('vectorwave.search.execution_search.find_executions')
+def test_find_by_trace_id(mock_find_executions):
+    """
+    Tests if find_by_trace_id filters by 'trace_id' and sorts by time.
+    """
+    find_by_trace_id("my-test-trace-123")
+
+    call_args = mock_find_executions.call_args
+
+    # [Fix] Check if filters_arg is a dict
+    filters_arg = call_args.kwargs['filters']
+    assert isinstance(filters_arg, dict)
+
+    # 1. Verify trace_id filter
+    assert filters_arg['trace_id'] == 'my-test-trace-123'
+
+    # 2. Verify sort order (time ascending)
+    assert call_args.kwargs['sort_by'] == 'timestamp_utc'
+    assert call_args.kwargs['sort_ascending'] == True
+    assert call_args.kwargs['limit'] == 100

{vectorwave-0.1.4 → vectorwave-0.1.5}/src/vectorwave/core/decorator.py

@@ -76,6 +76,8 @@ def vectorize(search_description: str,
                                 key
                             )
 
+            static_properties.update(valid_execution_tags)
+
             batch.add_object(
                 collection=settings.COLLECTION_NAME,
                 properties=static_properties,

{vectorwave-0.1.4 → vectorwave-0.1.5}/src/vectorwave/models/db_config.py

@@ -41,6 +41,10 @@ class WeaviateSettings(BaseSettings):
     global_custom_values: Optional[Dict[str, Any]] = None
     failure_mapping: Optional[Dict[str, str]] = None
 
+    ALERTER_STRATEGY: str = "none"
+    ALERTER_WEBHOOK_URL: Optional[str] = None
+    ALERTER_MIN_LEVEL: str = "ERROR" 
+
     model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8",extra='ignore')
 
 

vectorwave-0.1.5/src/vectorwave/monitoring/alert/base.py

@@ -0,0 +1,8 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Any
+
+
+class BaseAlerter(ABC):
+    @abstractmethod
+    def notify(self, error_log: Dict[str, Any]):
+        pass

vectorwave-0.1.5/src/vectorwave/monitoring/alert/factory.py

@@ -0,0 +1,19 @@
+from functools import lru_cache
+from ...models.db_config import get_weaviate_settings
+from .base import BaseAlerter
+from .webhook_alerter import WebhookAlerter
+from .null_alerter import NullAlerter
+
+@lru_cache()
+def get_alerter() -> BaseAlerter:
+    settings = get_weaviate_settings()
+    strategy = settings.ALERTER_STRATEGY.lower()
+
+    if strategy == "webhook":
+        if not settings.ALERTER_WEBHOOK_URL:
+            print("Warning: ALERTER_STRATEGY='webhook' but ALERTER_WEBHOOK_URL is not set. Using 'none'.")
+            return NullAlerter()
+        return WebhookAlerter(url=settings.ALERTER_WEBHOOK_URL)
+
+    # 기본값
+    return NullAlerter()

vectorwave-0.1.5/src/vectorwave/monitoring/alert/null_alerter.py

@@ -0,0 +1,7 @@
+from .base import BaseAlerter
+from typing import Dict, Any
+
+class NullAlerter(BaseAlerter):
+
+    def notify(self, error_log: Dict[str, Any]):
+        pass

vectorwave-0.1.5/src/vectorwave/monitoring/alert/webhook_alerter.py

@@ -0,0 +1,69 @@
+import requests
+from .base import BaseAlerter
+from typing import Dict, Any
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class WebhookAlerter(BaseAlerter):
+    def __init__(self, url: str):
+        self.url = url
+
+        self.STANDARD_KEYS = {
+            'trace_id', 'span_id', 'function_name', 'timestamp_utc',
+            'duration_ms', 'status', 'error_message', 'error_code'
+        }
+
+    def notify(self, error_log: Dict[str, Any]):
+        try:
+            func_name = error_log.get('function_name', 'N/A')
+            error_code = error_log.get('error_code', 'UNKNOWN')
+            trace_id = error_log.get('trace_id', 'N/A')
+            duration = error_log.get('duration_ms', 0)
+            timestamp = error_log.get('timestamp_utc')
+
+            error_msg_full = error_log.get('error_message', 'No error message provided.')
+            error_msg_snippet = (error_msg_full[:1000] + '...') if len(error_msg_full) > 1000 else error_msg_full
+
+
+            fields = [
+                {"name": "Function Name", "value": f"`{func_name}`", "inline": True},
+                {"name": "Error Code", "value": f"`{error_code}`", "inline": True},
+                {"name": "Duration", "value": f"{duration:.2f} ms", "inline": True},
+                {"name": "Trace ID", "value": f"`{trace_id}`", "inline": False},
+            ]
+
+            for key, value in error_log.items():
+                if key not in self.STANDARD_KEYS and value is not None:
+                    value_str = str(value)
+                    if value_str:
+                        fields.append(
+                            {"name": f"Attribute: {key}", "value": f"`{value_str}`", "inline": True}
+                        )
+
+            formatted_payload = {
+                "username": "VectorWave Alerter",
+                "embeds": [
+                    {
+                        "title": f"🚨 VectorWave ERROR: {func_name}",
+                        "description": f"```python\n{error_msg_snippet}\n```",
+                        "color": 15158332,  # Discord Red
+                        "fields": fields,
+                        "timestamp": timestamp if timestamp else None
+                    }
+                ]
+            }
+
+            requests.post(self.url, json=formatted_payload, timeout=5)
+
+        except Exception as e:
+            logger.error(f"WebhookAlerter failed to format or send notification: {e}")
+
+            try:
+                fallback_payload = {
+                    "content": f"🚨 ERROR (Fallback): {error_log.get('function_name')}\nCode: {error_log.get('error_code')}"
+                }
+                requests.post(self.url, json=fallback_payload, timeout=3)
+            except Exception as fe:
+                logger.error(f"WebhookAlerter fallback also failed: {fe}")