vectorwave 0.1.8__tar.gz → 0.1.9__tar.gz

{vectorwave-0.1.8/src/vectorwave.egg-info → vectorwave-0.1.9}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: vectorwave
-Version: 0.1.8
+Version: 0.1.9
 Summary: VectorWave: Seamless Auto-Vectorization Framework
 Author-email: junyeonggim <junyeonggim5@gmail.com>
 License-Expression: MIT
-Project-URL: Repository, https://github.com/republicofgamja/vtm
+Project-URL: Repository, https://github.com/cozymori/vectorwave
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -130,62 +130,56 @@ process_payment("user_789", 5000)
 
 To use the LLM feature, you must specify dependencies and environment variables.
 
-> #### Prerequisites for AI Auto-Documentation
->
-> To use the AI-powered documentation feature, you must have the `openai` library installed and configure your API key.
->
-> 1.  **Install Library:**
-      >
-      >     ```bash
->     pip install openai
->     ```
->
-> 2.  **Set API Key:** Add your valid OpenAI API key to your `.env` file.
-      >
-      >     ```text
->     OPENAI_API_KEY="sk-proj-YOUR_API_KEY_HERE"
->     # WEAVIATE_GENERATIVE_MODULE="generative-openai" (Required to enable the Weaviate module when using OpenAI LLM)
->     ```
+#### Prerequisites for AI Auto-Documentation
+
+To use the AI-powered documentation feature, you must have the `openai` library installed and configure your API key.
+
+1. **Install Library:**
+    ```bash
+    pip install openai
+    ```
+
+2. **Set API Key:** Add your valid OpenAI API key to your `.env` file.
+    ```ini
+    OPENAI_API_KEY="sk-proj-YOUR_API_KEY_HERE"
+    # WEAVIATE_GENERATIVE_MODULE="generative-openai" (Required to enable the Weaviate module when using OpenAI LLM)
+    ```
 
 ### 2.2. 🚀 Usage: Auto-Generating Function Metadata (Auto=True)
 
 Instead of manually defining `search_description` and `sequence_narrative`, you can use the `auto=True` flag.
 
-> #### 3\. Automatic Function Metadata Generation (Auto=True)
->
-> You can use the `auto=True` flag instead of manually defining `search_description` and `sequence_narrative`.
->
-> 1.  **Mark Function:** Set `auto=True`. It is **strongly recommended to include a detailed Docstring** to enhance the LLM's analysis quality.
-      >
-      >     ```python
->     # Code from vectorwave/test_ex/example.py
->     @vectorize(auto=True, team="loyalty-program")
->     def calculate_loyalty_points(purchase_amount: int, is_vip: bool):
->         """
->         Function to calculate loyalty points based on purchase amount.
->         VIP customers earn double points.
->         """
->         points = purchase_amount // 10
->         if is_vip:
->             points *= 2
->         return {"points": points, "tier": "VIP" if is_vip else "Regular"}
->     ```
->
-> 2.  **Trigger Generation:** Call `generate_and_register_metadata()` **immediately after** all `@vectorize` function definitions are complete. This function calls the LLM, vectorizes the generated metadata, and registers it to the DB.
-      >
-      >     ```python
->     # ... (After defining the calculate_loyalty_points function above)
->     ```
-
-> ````
-> # [Mandatory] Must be called after all function definitions are complete.
-> print("🚀 Checking for functions needing auto-documentation...")
-> generate_and_register_metadata()
-> ```
-> ````
->
-> *Note: Since this process involves LLM API calls, it can cause **latency** if run during server startup. It is recommended to execute this via a separate management script or an admin API endpoint in a production environment.*
+#### 3. Automatic Function Metadata Generation (Auto=True)
+
+You can use the `auto=True` flag instead of manually defining `search_description` and `sequence_narrative`.
+
+1. **Mark Function:** Set `auto=True`. It is **strongly recommended to include a detailed Docstring** to enhance the LLM's analysis quality.
+
+    ```python
+    # Code from vectorwave/test_ex/example.py
+    @vectorize(auto=True, team="loyalty-program")
+    def calculate_loyalty_points(purchase_amount: int, is_vip: bool):
+        """
+        Function to calculate loyalty points based on purchase amount.
+        VIP customers earn double points.
+        """
+        points = purchase_amount // 10
+        if is_vip:
+            points *= 2
+        return {"points": points, "tier": "VIP" if is_vip else "Regular"}
+    ```
+
+2. **Trigger Generation:** Call `generate_and_register_metadata()` **immediately after** all `@vectorize` function definitions are complete. This function calls the LLM, vectorizes the generated metadata, and registers it to the DB.
+
+    ```python
+    # ... (After defining the calculate_loyalty_points function above)
+
+    # [Mandatory] Must be called after all function definitions are complete.
+    print("🚀 Checking for functions needing auto-documentation...")
+    generate_and_register_metadata()
+    ```
 
+> **Note:** Since this process involves LLM API calls, it can cause **latency** if run during server startup. It is recommended to execute this via a separate management script or an admin API endpoint in a production environment.
 -----
 
 #### Semantic Caching Example

{vectorwave-0.1.8 → vectorwave-0.1.9}/Readme.md

@@ -104,62 +104,56 @@ process_payment("user_789", 5000)
 
 To use the LLM feature, you must specify dependencies and environment variables.
 
-> #### Prerequisites for AI Auto-Documentation
->
-> To use the AI-powered documentation feature, you must have the `openai` library installed and configure your API key.
->
-> 1.  **Install Library:**
-      >
-      >     ```bash
->     pip install openai
->     ```
->
-> 2.  **Set API Key:** Add your valid OpenAI API key to your `.env` file.
-      >
-      >     ```text
->     OPENAI_API_KEY="sk-proj-YOUR_API_KEY_HERE"
->     # WEAVIATE_GENERATIVE_MODULE="generative-openai" (Required to enable the Weaviate module when using OpenAI LLM)
->     ```
+#### Prerequisites for AI Auto-Documentation
+
+To use the AI-powered documentation feature, you must have the `openai` library installed and configure your API key.
+
+1. **Install Library:**
+    ```bash
+    pip install openai
+    ```
+
+2. **Set API Key:** Add your valid OpenAI API key to your `.env` file.
+    ```ini
+    OPENAI_API_KEY="sk-proj-YOUR_API_KEY_HERE"
+    # WEAVIATE_GENERATIVE_MODULE="generative-openai" (Required to enable the Weaviate module when using OpenAI LLM)
+    ```
 
 ### 2.2. 🚀 Usage: Auto-Generating Function Metadata (Auto=True)
 
 Instead of manually defining `search_description` and `sequence_narrative`, you can use the `auto=True` flag.
 
-> #### 3\. Automatic Function Metadata Generation (Auto=True)
->
-> You can use the `auto=True` flag instead of manually defining `search_description` and `sequence_narrative`.
->
-> 1.  **Mark Function:** Set `auto=True`. It is **strongly recommended to include a detailed Docstring** to enhance the LLM's analysis quality.
-      >
-      >     ```python
->     # Code from vectorwave/test_ex/example.py
->     @vectorize(auto=True, team="loyalty-program")
->     def calculate_loyalty_points(purchase_amount: int, is_vip: bool):
->         """
->         Function to calculate loyalty points based on purchase amount.
->         VIP customers earn double points.
->         """
->         points = purchase_amount // 10
->         if is_vip:
->             points *= 2
->         return {"points": points, "tier": "VIP" if is_vip else "Regular"}
->     ```
->
-> 2.  **Trigger Generation:** Call `generate_and_register_metadata()` **immediately after** all `@vectorize` function definitions are complete. This function calls the LLM, vectorizes the generated metadata, and registers it to the DB.
-      >
-      >     ```python
->     # ... (After defining the calculate_loyalty_points function above)
->     ```
-
-> ````
-> # [Mandatory] Must be called after all function definitions are complete.
-> print("🚀 Checking for functions needing auto-documentation...")
-> generate_and_register_metadata()
-> ```
-> ````
->
-> *Note: Since this process involves LLM API calls, it can cause **latency** if run during server startup. It is recommended to execute this via a separate management script or an admin API endpoint in a production environment.*
+#### 3. Automatic Function Metadata Generation (Auto=True)
+
+You can use the `auto=True` flag instead of manually defining `search_description` and `sequence_narrative`.
+
+1. **Mark Function:** Set `auto=True`. It is **strongly recommended to include a detailed Docstring** to enhance the LLM's analysis quality.
+
+    ```python
+    # Code from vectorwave/test_ex/example.py
+    @vectorize(auto=True, team="loyalty-program")
+    def calculate_loyalty_points(purchase_amount: int, is_vip: bool):
+        """
+        Function to calculate loyalty points based on purchase amount.
+        VIP customers earn double points.
+        """
+        points = purchase_amount // 10
+        if is_vip:
+            points *= 2
+        return {"points": points, "tier": "VIP" if is_vip else "Regular"}
+    ```
+
+2. **Trigger Generation:** Call `generate_and_register_metadata()` **immediately after** all `@vectorize` function definitions are complete. This function calls the LLM, vectorizes the generated metadata, and registers it to the DB.
+
+    ```python
+    # ... (After defining the calculate_loyalty_points function above)
+
+    # [Mandatory] Must be called after all function definitions are complete.
+    print("🚀 Checking for functions needing auto-documentation...")
+    generate_and_register_metadata()
+    ```
 
+> **Note:** Since this process involves LLM API calls, it can cause **latency** if run during server startup. It is recommended to execute this via a separate management script or an admin API endpoint in a production environment.
 -----
 
 #### Semantic Caching Example

{vectorwave-0.1.8 → vectorwave-0.1.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vectorwave"
-version = "0.1.8"
+version = "0.1.9"
 authors = [
     { name = "junyeonggim", email = "junyeonggim5@gmail.com" },
 ]
@@ -32,7 +32,7 @@ dependencies = [
 ]
 
 [project.urls]
-Repository = "https://github.com/republicofgamja/vtm"
+Repository = "https://github.com/cozymori/vectorwave"
 
 [tool.setuptools.packages.find]
 where = ["src"]

{vectorwave-0.1.8 → vectorwave-0.1.9}/src/tests/core/test_semantic_caching.py

@@ -14,6 +14,8 @@ 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.vectorizer.factory import get_vectorizer as real_get_vectorizer
+from vectorwave.monitoring.tracer import _create_input_vector_data
+
 
 # --- Fixture Setup ---
 
@@ -326,7 +328,6 @@ def test_tracer_input_vector_data_and_masking(mock_caching_deps):
     """
     Tests that the _create_input_vector_data function masks sensitive keys.
     """
-    from vectorwave.monitoring.tracer import _create_input_vector_data
 
     # Arrange: settings has sensitive_keys={"secret_key"}
     settings = mock_caching_deps["settings"]
@@ -343,10 +344,12 @@ def test_tracer_input_vector_data_and_masking(mock_caching_deps):
     text_content = input_data["text"]
     assert "test_func" in text_content
     assert "amount" in text_content
-    assert "[MASKED]" in text_content
+
+    assert "[MASKED]" not in text_content
+    assert "secret_key" not in text_content
     assert "my_top_secret" not in text_content
 
-    # 2. Verification: Check if masking is included in the properties dictionary
+    # 2. Verification: Check stored properties
     props = input_data["properties"]
     assert props["function"] == "test_func"
     assert props["kwargs"]["amount"] == 100

{vectorwave-0.1.8 → vectorwave-0.1.9}/src/tests/search/test_execution_search.py

@@ -54,7 +54,6 @@ mock_db_errors = [
     {"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()
@@ -80,10 +79,31 @@ def test_find_recent_errors(mock_find_executions):
     filters_arg = call_args.kwargs['filters']
 
     assert filters_arg['status'] == 'ERROR'
-    assert filters_arg['error_code'] == 'INVALID_INPUT'
+    assert filters_arg['error_code'] == ['INVALID_INPUT']
     assert filters_arg['timestamp_utc__gte'] == expected_time_limit_iso
 
 
+@patch('vectorwave.search.execution_search.datetime', MockDateTime)
+@patch('vectorwave.search.execution_search.find_executions')
+def test_find_recent_errors_multi_code(mock_find_executions):
+    """
+    Tests if find_recent_errors handles multiple error codes correctly by passing the list.
+    (Tests the newly implemented multi-code filtering path)
+    """
+    error_list = ["INVALID_INPUT", "TIMEOUT_ERROR"]
+    find_recent_errors(minutes_ago=20, limit=5, error_codes=error_list)
+
+    call_args = mock_find_executions.call_args
+    filters_arg = call_args.kwargs['filters']
+
+    assert filters_arg['status'] == 'ERROR'
+    assert filters_arg['error_code'] == error_list
+    assert call_args.kwargs['limit'] == 5
+
+    expected_time_limit_iso_20 = (mock_now - timedelta(minutes=20)).isoformat()
+    assert filters_arg['timestamp_utc__gte'] == expected_time_limit_iso_20
+
+
 @patch('vectorwave.search.execution_search.find_executions')
 def test_find_slowest_executions(mock_find_executions):
     """
@@ -122,4 +142,4 @@ def test_find_by_trace_id(mock_find_executions):
     # 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
+    assert call_args.kwargs['limit'] == 100

{vectorwave-0.1.8 → vectorwave-0.1.9}/src/tests/utils/test_replayer.py

@@ -1,5 +1,7 @@
 import pytest
 import json
+import asyncio
+import inspect
 from unittest.mock import MagicMock, patch
 from vectorwave.utils.replayer import VectorWaveReplayer
 
@@ -194,4 +196,46 @@ def test_replay_argument_filtering(mock_replayer_deps):
 
     # Assert
     # Should only be called with 'a=10', excluding 'team' and 'priority'
-    mock_func.assert_called_once_with(a=10)
+    mock_func.assert_called_once_with(a=10)
+
+def test_replay_async_function_execution_fixed(mock_replayer_deps):
+    """
+    [Case 5] Async Function Test (FIXED): Tests the async execution path using patching
+    of the import mechanism and executing the actual async function via asyncio.run.
+    """
+    # Arrange
+    replayer = VectorWaveReplayer()
+
+    # 1. DB Mock Data
+    inputs = {"a": 1, "b": 2}
+    expected_result = 3
+    mock_logs = [create_mock_log("uuid-async-1", inputs, expected_result)]
+    mock_replayer_deps["query"].fetch_objects.return_value.objects = mock_logs
+
+    # 2. Define the actual ASYNC function for replayer to execute
+    async def real_async_add(a, b):
+        # This function will be called and executed by asyncio.run
+        await asyncio.sleep(0.001)
+        return a + b
+
+    # Manually attach the signature for the replayer's inspection check to pass
+    setattr(real_async_add, '__signature__', inspect.Signature([
+        inspect.Parameter('a', inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        inspect.Parameter('b', inspect.Parameter.POSITIONAL_OR_KEYWORD)
+    ]))
+
+    # 3. Patch importlib.import_module to return a mock module that contains the target function
+    mock_module = MagicMock()
+    mock_module.async_add = real_async_add # The mock module must have the function
+
+    with patch("vectorwave.utils.replayer.importlib.import_module", return_value=mock_module):
+
+        # Act
+        # replayer.replay (sync function) calls asyncio.run(real_async_add(**inputs)) internally.
+        result = replayer.replay("my_module.async_add", limit=1)
+
+    # Assert
+    # 1. The result should be successful and match the expected output
+    assert result["passed"] == 1
+    assert result["failed"] == 0
+    assert result["failures"] == []

vectorwave-0.1.9/src/tests/utils/test_status.py

@@ -0,0 +1,126 @@
+import pytest
+from unittest.mock import MagicMock, patch
+from vectorwave.utils.status import get_db_status, get_registered_functions
+from vectorwave.models.db_config import WeaviateSettings
+
+# --- Fixtures ---
+
+@pytest.fixture
+def mock_status_deps(monkeypatch):
+    """
+    Mocks dependencies of status.py (get_cached_client, get_weaviate_settings).
+    """
+    # 1. Mock Weaviate Client
+    mock_client = MagicMock()
+    mock_get_client = MagicMock(return_value=mock_client)
+
+    # 2. Mock Settings
+    mock_settings = WeaviateSettings(COLLECTION_NAME="TestFunctions")
+    mock_get_settings = MagicMock(return_value=mock_settings)
+
+    # 3. Apply Patches
+    monkeypatch.setattr("vectorwave.utils.status.get_cached_client", mock_get_client)
+    monkeypatch.setattr("vectorwave.utils.status.get_weaviate_settings", mock_get_settings)
+
+    return {
+        "client": mock_client,
+        "settings": mock_settings,
+        "get_client": mock_get_client
+    }
+
+# --- Tests for get_db_status ---
+
+def test_get_db_status_ready(mock_status_deps):
+    """
+    Case 1: Test if True is returned when DB is connected and ready.
+    """
+    mock_status_deps["client"].is_ready.return_value = True
+
+    assert get_db_status() is True
+    mock_status_deps["client"].is_ready.assert_called_once()
+
+def test_get_db_status_not_ready(mock_status_deps):
+    """
+    Case 2: Test if False is returned when DB is connected but not ready.
+    """
+    mock_status_deps["client"].is_ready.return_value = False
+
+    assert get_db_status() is False
+
+def test_get_db_status_exception(mock_status_deps):
+    """
+    Case 3: Test if False is returned and error is logged when an exception occurs during DB connection.
+    """
+    # Set exception to occur on client call
+    mock_status_deps["get_client"].side_effect = Exception("Connection Error")
+
+    assert get_db_status() is False
+
+# --- Tests for get_registered_functions ---
+
+@patch("vectorwave.utils.status.get_db_status")
+def test_get_registered_functions_db_offline(mock_get_db_status, mock_status_deps):
+    """
+    Case 4: Test if an empty list is returned when DB is offline (False).
+    """
+    mock_get_db_status.return_value = False
+
+    result = get_registered_functions()
+
+    assert result == []
+    # Should not access client or collection if DB is offline
+    mock_status_deps["client"].collections.get.assert_not_called()
+
+@patch("vectorwave.utils.status.get_db_status")
+def test_get_registered_functions_success(mock_get_db_status, mock_status_deps):
+    """
+    Case 5: Test if the list of registered functions is returned correctly.
+    """
+    # 1. Arrange
+    mock_get_db_status.return_value = True
+
+    # Mock collection and query results
+    mock_collection = MagicMock()
+    mock_status_deps["client"].collections.get.return_value = mock_collection
+
+    # Create fake Weaviate objects
+    obj1 = MagicMock()
+    obj1.properties = {"function_name": "func_a", "module_name": "mod_a"}
+    obj2 = MagicMock()
+    obj2.properties = {"function_name": "func_b", "module_name": "mod_b"}
+
+    # Mock result of fetch_objects call
+    mock_collection.iterator.return_value = [obj1, obj2]
+
+    # 2. Act
+    result = get_registered_functions()
+
+    # 3. Assert
+    assert len(result) == 2
+    assert result[0]["function_name"] == "func_a"
+    assert result[1]["function_name"] == "func_b"
+
+    # Verify correct name usage when retrieving collection
+    mock_status_deps["client"].collections.get.assert_called_with("TestFunctions")
+
+    mock_collection.iterator.assert_called_once()
+    call_kwargs = mock_collection.iterator.call_args.kwargs
+    assert "return_properties" in call_kwargs
+    assert "function_name" in call_kwargs["return_properties"]
+
+@patch("vectorwave.utils.status.get_db_status")
+def test_get_registered_functions_exception(mock_get_db_status, mock_status_deps):
+    """
+    Case 6: Test if an empty list is returned and error is handled when an exception occurs during retrieval.
+    """
+    # 1. Arrange
+    mock_get_db_status.return_value = True
+
+    # Induce exception during collection retrieval
+    mock_status_deps["client"].collections.get.side_effect = Exception("Query Failed")
+
+    # 2. Act
+    result = get_registered_functions()
+
+    # 3. Assert
+    assert result == []

{vectorwave-0.1.8 → vectorwave-0.1.9}/src/vectorwave/database/db_search.py

@@ -1,7 +1,7 @@
 import logging
 import weaviate
 import weaviate.classes as wvc
-from typing import Dict, Any, Optional, List
+from typing import Dict, Any, Optional, List, Tuple
 
 from weaviate.collections.classes.filters import _Filters
 from weaviate.classes.query import Filter
@@ -33,7 +33,11 @@ def _build_weaviate_filters(filters: Optional[Dict[str, Any]]) -> _Filters | Non
             prop = Filter.by_property(prop_name)
 
             if operator == 'equal':
-                filter_list.append(prop.equal(value))
+                if isinstance(value, list) and value:
+                    # Use contains_any for matching any value in the list (equivalent to SQL IN)
+                    filter_list.append(prop.contains_any(value))
+                else:
+                    filter_list.append(prop.equal(value))
             elif operator == 'not_equal':
                 filter_list.append(prop.not_equal(value))
             elif operator == 'gte':  # Greater than or equal
@@ -356,3 +360,52 @@ def search_functions_hybrid(
     except Exception as e:
         logger.error("Error during Weaviate Hybrid search: %s", e)
         raise WeaviateConnectionError(f"Failed to execute 'search_functions_hybrid': {e}")
+
+
+def check_semantic_drift(
+        vector: List[float],
+        function_name: str,
+        threshold: float,
+        k: int = 5
+) -> Tuple[bool, float, Optional[str]]:
+    """
+    KNN based semantic drift check.
+    """
+    try:
+        settings = get_weaviate_settings()
+        client = get_cached_client()
+        collection = client.collections.get(settings.EXECUTION_COLLECTION_NAME)
+
+        response = collection.query.near_vector(
+            near_vector=vector,
+            limit=k,
+            filters=(
+                    wvc.query.Filter.by_property("function_name").equal(function_name) &
+                    wvc.query.Filter.by_property("status").equal("SUCCESS")
+            ),
+            return_metadata=wvc.query.MetadataQuery(distance=True),
+            return_properties=[]
+        )
+
+        objects = response.objects
+        if not objects:
+            return False, 0.0, None
+
+        distances = [obj.metadata.distance for obj in objects]
+        avg_distance = sum(distances) / len(distances)
+
+        nearest_uuid = str(objects[0].uuid)
+
+        is_drift = avg_distance > threshold
+
+        if is_drift:
+            logger.warning(
+                f"🚨 [Semantic Drift] '{function_name}' detected anomaly! "
+                f"Avg Distance (k={len(objects)}): {avg_distance:.4f} (Threshold: {threshold})"
+            )
+
+        return is_drift, avg_distance, nearest_uuid
+
+    except Exception as e:
+        logger.error(f"Failed to check semantic drift: {e}")
+        return False, 0.0, None

{vectorwave-0.1.8 → vectorwave-0.1.9}/src/vectorwave/models/db_config.py

@@ -49,6 +49,10 @@ class WeaviateSettings(BaseSettings):
     ALERTER_WEBHOOK_URL: Optional[str] = None
     ALERTER_MIN_LEVEL: str = "ERROR"
 
+    DRIFT_DETECTION_ENABLED: bool = False
+    DRIFT_DISTANCE_THRESHOLD: float = 0.25
+    DRIFT_NEIGHBOR_AMOUNT: int = 5
+
     SENSITIVE_FIELD_NAMES: str = "password,api_key,token,secret,auth_token"
     sensitive_keys: Set[str] = set()
 

{vectorwave-0.1.8 → vectorwave-0.1.9}/src/vectorwave/monitoring/alert/factory.py

@@ -3,6 +3,9 @@ from ...models.db_config import get_weaviate_settings
 from .base import BaseAlerter
 from .webhook_alerter import WebhookAlerter
 from .null_alerter import NullAlerter
+import logging
+
+logger = logging.getLogger(__name__)
 
 @lru_cache()
 def get_alerter() -> BaseAlerter:
@@ -11,9 +14,8 @@ def get_alerter() -> BaseAlerter:
 
     if strategy == "webhook":
         if not settings.ALERTER_WEBHOOK_URL:
-            print("Warning: ALERTER_STRATEGY='webhook' but ALERTER_WEBHOOK_URL is not set. Using 'none'.")
+            logger.warning("ALERTER_STRATEGY='webhook' but ALERTER_WEBHOOK_URL is not set. Using 'none'.")
             return NullAlerter()
         return WebhookAlerter(url=settings.ALERTER_WEBHOOK_URL)
 
-    # 기본값
     return NullAlerter()