vectorwave 0.2.2__tar.gz → 0.2.4__tar.gz

{vectorwave-0.2.2/src/vectorwave.egg-info → vectorwave-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectorwave
-Version: 0.2.2
+Version: 0.2.4
 Summary: VectorWave: Seamless Auto-Vectorization Framework
 Author-email: junyeonggim <junyeonggim5@gmail.com>
 License-Expression: MIT
@@ -618,6 +618,40 @@ archiver.export_and_clear(
 {"messages": [{"role": "user", "content": "{\"price\": 100, \"tax\": 0.1}"}, {"role": "assistant", "content": "110.0"}]}
 ```
 
+## 🌊 Auto-Injection (Zero-Code Change Integration)
+
+You don't need to modify your business logic to use VectorWave. Use `VectorWaveAutoInjector` to inject functionality externally.
+
+### How to use
+
+1. **Configure Global Settings**: Set default values like `team`, `priority`, or `auto` (pending mode).
+2. **Inject Modules**: Specify the target module path string.
+
+```python
+from vectorwave import initialize_database, VectorWaveAutoInjector, generate_and_register_metadata
+
+# 1. Initialize DB
+initialize_database()
+
+# 2. Configure AutoInjector (Global Settings)
+VectorWaveAutoInjector.configure(
+    team="billing-team",
+    priority=1,
+    auto=True  # True: Collect metadata in memory (Pending), False: Save immediately to DB
+)
+
+# 3. Inject VectorWave into your module
+# (No need to add @vectorize decorators in 'my_service.payment' code!)
+VectorWaveAutoInjector.inject("my_service.payment")
+
+# 4. Register Metadata (If auto=True)
+generate_and_register_metadata()
+
+# 5. Run your business logic
+import my_service.payment
+my_service.payment.process_transaction()
+```
+
 ## 🤝 Contributing
 
 We welcome all forms of contributions, including bug reports, feature requests, and code contributions. Please refer to [CONTRIBUTING.md](https://www.google.com/search?q=httpsS://www.google.com/search%3Fq%3DCONTRIBUTING.md) for details.

{vectorwave-0.2.2 → vectorwave-0.2.4}/Readme.md

@@ -592,6 +592,40 @@ archiver.export_and_clear(
 {"messages": [{"role": "user", "content": "{\"price\": 100, \"tax\": 0.1}"}, {"role": "assistant", "content": "110.0"}]}
 ```
 
+## 🌊 Auto-Injection (Zero-Code Change Integration)
+
+You don't need to modify your business logic to use VectorWave. Use `VectorWaveAutoInjector` to inject functionality externally.
+
+### How to use
+
+1. **Configure Global Settings**: Set default values like `team`, `priority`, or `auto` (pending mode).
+2. **Inject Modules**: Specify the target module path string.
+
+```python
+from vectorwave import initialize_database, VectorWaveAutoInjector, generate_and_register_metadata
+
+# 1. Initialize DB
+initialize_database()
+
+# 2. Configure AutoInjector (Global Settings)
+VectorWaveAutoInjector.configure(
+    team="billing-team",
+    priority=1,
+    auto=True  # True: Collect metadata in memory (Pending), False: Save immediately to DB
+)
+
+# 3. Inject VectorWave into your module
+# (No need to add @vectorize decorators in 'my_service.payment' code!)
+VectorWaveAutoInjector.inject("my_service.payment")
+
+# 4. Register Metadata (If auto=True)
+generate_and_register_metadata()
+
+# 5. Run your business logic
+import my_service.payment
+my_service.payment.process_transaction()
+```
+
 ## 🤝 Contributing
 
 We welcome all forms of contributions, including bug reports, feature requests, and code contributions. Please refer to [CONTRIBUTING.md](https://www.google.com/search?q=httpsS://www.google.com/search%3Fq%3DCONTRIBUTING.md) for details.

{vectorwave-0.2.2 → vectorwave-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vectorwave"
-version = "0.2.02"
+version = "0.2.04"
 authors = [
     { name = "junyeonggim", email = "junyeonggim5@gmail.com" },
 ]

vectorwave-0.2.4/src/tests/core/test_auto_injector.py

@@ -0,0 +1,228 @@
+import pytest
+import sys
+import types
+from unittest.mock import MagicMock, ANY
+from vectorwave.core.auto_injector import VectorWaveAutoInjector, create_smart_wrapper
+
+# --- Fixtures ---
+
+@pytest.fixture
+def mock_target_module():
+    """Dynamically creates a fake module for testing."""
+    module_name = "fake_business_logic"
+    mod = types.ModuleType(module_name)
+
+    # Define functions for testing
+    def func_a(x): return x + 1
+    def func_b(y): return y * 2
+
+    # Set __module__ attribute so the Injector recognizes them as 'functions of this module'
+    func_a.__module__ = module_name
+    func_b.__module__ = module_name
+
+    mod.func_a = func_a
+    mod.func_b = func_b
+
+    # Register to sys.modules
+    sys.modules[module_name] = mod
+    yield mod
+    # Cleanup
+    del sys.modules[module_name]
+
+@pytest.fixture
+def mock_deps(monkeypatch):
+    """
+    Mocks vectorize, trace_span, and contextvar that auto_injector depends on.
+    """
+    mock_vectorize = MagicMock()
+    mock_trace_span = MagicMock()
+    mock_tracer_var = MagicMock()
+
+    # Mock vectorize: @vectorize(...) -> decorator -> returns root_wrapper
+    def vectorize_side_effect(**kwargs):
+        def decorator(func):
+            # Return a mock acting as root_wrapper (Default behavior: execute original function)
+            root_wrapper = MagicMock(side_effect=func)
+            return root_wrapper
+        return decorator
+
+    # [Modified] Mock trace_span: Modified to accept positional arguments (*args)
+    def trace_span_side_effect(*args, **kwargs):
+        # Case 1: Called as trace_span(func, capture_return_value=True)
+        if args and callable(args[0]):
+            func = args[0]
+            def wrapper(*w_args, **w_kwargs):
+                return func(*w_args, **w_kwargs)
+            return wrapper
+
+        # Case 2: Called as a decorator factory @trace_span(...)
+        def decorator(func):
+            def wrapper(*w_args, **w_kwargs):
+                return func(*w_args, **w_kwargs)
+            return wrapper
+        return decorator
+
+    mock_vectorize.side_effect = vectorize_side_effect
+    mock_trace_span.side_effect = trace_span_side_effect
+
+    # Patch according to the module path
+    monkeypatch.setattr("vectorwave.core.auto_injector.vectorize", mock_vectorize)
+    monkeypatch.setattr("vectorwave.core.auto_injector.trace_span", mock_trace_span)
+    monkeypatch.setattr("vectorwave.core.auto_injector.current_tracer_var", mock_tracer_var)
+
+    return {
+        "vectorize": mock_vectorize,
+        "trace_span": mock_trace_span,
+        "tracer_var": mock_tracer_var
+    }
+
+@pytest.fixture
+def mock_multiple_modules():
+    """Dynamically creates two different fake modules (Payment, Auth)."""
+    name_a = "service_payment"
+    name_b = "service_auth"
+
+    mod_a = types.ModuleType(name_a)
+    mod_b = types.ModuleType(name_b)
+
+    def pay(x): return x
+    def login(x): return x
+
+    pay.__module__ = name_a
+    login.__module__ = name_b
+
+    mod_a.process_payment = pay
+    mod_b.login_user = login
+
+    sys.modules[name_a] = mod_a
+    sys.modules[name_b] = mod_b
+
+    yield mod_a, mod_b
+
+    del sys.modules[name_a]
+    del sys.modules[name_b]
+
+# --- Test Cases ---
+
+def test_inject_calls_vectorize_immediately(mock_target_module, mock_deps):
+    """
+    Case 1: Verify that vectorize is called immediately at injection time to register metadata.
+    """
+    # Act
+    VectorWaveAutoInjector.inject("fake_business_logic", team="test-team")
+
+    # Assert
+    # 1. vectorize should have been called (Immediate registration)
+    mock_deps["vectorize"].assert_called()
+
+    # 2. Verify passed configuration
+    call_kwargs = mock_deps["vectorize"].call_args.kwargs
+    assert call_kwargs["team"] == "test-team"
+
+    # 3. Verify the function is wrapped
+    assert getattr(mock_target_module.func_a, "_is_vectorized") is True
+
+def test_smart_wrapper_root_execution(mock_target_module, mock_deps):
+    """
+    Case 2: Verify that the pre-created root_wrapper is executed when there is no tracer (Root).
+    """
+    # Arrange
+    mock_deps["tracer_var"].get.return_value = None # No parent trace
+
+    # [Modified] Remove fixture's side_effect so return_value setting takes effect.
+    mock_deps["vectorize"].side_effect = None
+
+    # vectorize(...) -> decorator_mock returns -> decorator_mock(func) -> root_wrapper_mock returns
+    decorator_mock = MagicMock()
+    root_wrapper_mock = MagicMock(return_value=11)
+
+    mock_deps["vectorize"].return_value = decorator_mock
+    decorator_mock.return_value = root_wrapper_mock
+
+    VectorWaveAutoInjector.inject("fake_business_logic")
+
+    # Act
+    result = mock_target_module.func_a(10)
+
+    # Assert
+    assert result == 11
+    # root_wrapper should have been called
+    root_wrapper_mock.assert_called_once()
+    # trace_span should not be called (logic is already inside root_wrapper)
+    mock_deps["trace_span"].assert_not_called()
+
+def test_smart_wrapper_child_execution(mock_target_module, mock_deps):
+    """
+    Case 3: Verify that trace_span is dynamically called when there is a tracer (Child).
+    """
+    # Arrange
+    mock_deps["tracer_var"].get.return_value = MagicMock() # Parent trace exists
+
+    # [Modified] Remove side_effect and set Mock
+    mock_deps["vectorize"].side_effect = None
+
+    decorator_mock = MagicMock()
+    root_wrapper_mock = MagicMock(return_value=999) # Should not be called
+
+    mock_deps["vectorize"].return_value = decorator_mock
+    decorator_mock.return_value = root_wrapper_mock
+
+    VectorWaveAutoInjector.inject("fake_business_logic")
+
+    # Act
+    # trace_span mock is configured to call the original function (see fixture)
+    # func_b: y * 2 -> 5 * 2 = 10
+    result = mock_target_module.func_b(5)
+
+    # Assert
+    assert result == 10
+    # trace_span should have been called
+    mock_deps["trace_span"].assert_called()
+    # root_wrapper should not have been called
+    root_wrapper_mock.assert_not_called()
+
+def test_prevent_double_injection(mock_target_module, mock_deps):
+    """
+    Case 4: Verify that calling inject again on an already injected function does not result in double wrapping.
+    """
+    # 1. First Injection
+    VectorWaveAutoInjector.inject("fake_business_logic")
+    first_wrapped_func = mock_target_module.func_a
+    call_count_first = mock_deps["vectorize"].call_count
+
+    # 2. Second Injection
+    VectorWaveAutoInjector.inject("fake_business_logic")
+    second_wrapped_func = mock_target_module.func_a
+    call_count_second = mock_deps["vectorize"].call_count
+
+    # Assert
+    # Object addresses must be identical
+    assert first_wrapped_func is second_wrapped_func
+    # vectorize call count should not increase (Prevent duplicate registration)
+    assert call_count_first == call_count_second
+
+def test_inject_using_config_dictionary_pattern(mock_multiple_modules, mock_deps):
+    """
+    Case 5: Verify that configurations are correctly applied when injecting multiple modules in a batch.
+    """
+    mod_a, mod_b = mock_multiple_modules
+
+    # Injection
+    VectorWaveAutoInjector.configure(team="default") # Global config example
+
+    VectorWaveAutoInjector.inject("service_payment", priority=1)
+    VectorWaveAutoInjector.inject("service_auth", team="security")
+
+    # Verify: Check arguments passed to vectorize calls
+    calls = mock_deps["vectorize"].call_args_list
+    # Collect kwargs
+    configs = [c.kwargs for c in calls]
+
+    # service_payment: default team + priority 1
+    config_a = next((c for c in configs if c.get("priority") == 1), None)
+    assert config_a is not None
+    assert config_a["team"] == "default"
+
+    # service_auth: security team (override)
+    config_b = next((c for c in configs if c.get("team") == "security"), None)
+    assert config_b is not None

vectorwave-0.2.4/src/tests/core/test_auto_injector_real.py

@@ -0,0 +1,111 @@
+import pytest
+import sys
+import types
+from unittest.mock import patch, MagicMock
+
+# Import actual modules
+from vectorwave import vectorize, VectorWaveAutoInjector
+
+# --- Fixtures ---
+
+@pytest.fixture
+def mock_db_dependencies():
+    """
+    Mocks heavy dependencies to prevent @vectorize decorator from internally calling
+    DB or AI models.
+    (The wrapping logic itself runs for 'real')
+    """
+    with patch("vectorwave.core.decorator.get_batch_manager") as mock_batch, \
+            patch("vectorwave.core.decorator.get_vectorizer") as mock_vec, \
+            patch("vectorwave.core.decorator.function_cache_manager"), \
+            patch("vectorwave.core.decorator.get_weaviate_settings"), \
+            patch("vectorwave.core.decorator.generate_uuid5", return_value="mock-uuid"):
+
+        # Return fake DB settings (prevent errors)
+        mock_settings = MagicMock()
+        mock_settings.custom_properties = {}
+        mock_settings.COLLECTION_NAME = "VectorWaveFunction"
+        patch("vectorwave.core.decorator.get_weaviate_settings", return_value=mock_settings).start()
+
+        yield
+
+# --- Real Function Integration Test ---
+
+def test_real_function_mixed_usage(mock_db_dependencies):
+    """
+    [Integration Test] Verifies that double wrapping is prevented when mixing
+    actual @vectorize decorator and AutoInjector using real function objects.
+    """
+    # 1. Create a fake module (acts like a real Python module)
+    module_name = "my_real_test_module"
+    mod = types.ModuleType(module_name)
+
+    # -------------------------------------------------------
+    # (A) Manually vectorized function (Using Real Decorator)
+    # -------------------------------------------------------
+    @vectorize(team="manual_team", auto=True)
+    def manual_func(x):
+        return x + 1
+
+    # -------------------------------------------------------
+    # (B) Plain function without any decorator
+    # -------------------------------------------------------
+    def plain_func(y):
+        return y * 2
+
+    # [Important] Set __module__ so Injector recognizes them as internal functions
+    manual_func.__module__ = module_name
+    plain_func.__module__ = module_name
+
+    # Register functions to the module
+    mod.manual_func = manual_func
+    mod.plain_func = plain_func
+
+    # Register to sys.modules so importlib can find it
+    sys.modules[module_name] = mod
+
+    try:
+        # 2. Check state before injection
+        print("\n[Before Injection]")
+        print(f"manual_func vectorized? {getattr(mod.manual_func, '_is_vectorized', False)}")
+        print(f"plain_func vectorized?  {getattr(mod.plain_func, '_is_vectorized', False)}")
+
+        # manual_func should already have the decorator applied
+        assert getattr(mod.manual_func, "_is_vectorized", False) is True
+        # plain_func should be a pure function
+        assert getattr(mod.plain_func, "_is_vectorized", False) is False
+
+        # Save object ID of manual_func before injection (for comparison)
+        original_manual_func_id = id(mod.manual_func)
+
+        # -------------------------------------------------------
+        # 3. Execute AutoInjector (Real Injection)
+        # -------------------------------------------------------
+        print("\n🌊 Injecting VectorWave...")
+        VectorWaveAutoInjector.inject(module_name, team="auto_team")
+
+        # 4. Verify results
+        print("\n[After Injection]")
+
+        # (A) Verify manual_func: Prevent double wrapping
+        # If AutoInjector skipped it, the object ID should remain unchanged.
+        current_manual_func_id = id(mod.manual_func)
+
+        if current_manual_func_id == original_manual_func_id:
+            print("✅ manual_func: SKIPPED (Identity preserved)")
+        else:
+            print("❌ manual_func: WRAPPED AGAIN (Identity changed!)")
+
+        assert current_manual_func_id == original_manual_func_id, \
+            "Manually configured function was double-wrapped by AutoInjector!"
+
+        # (B) Verify plain_func: Auto-wrapping success
+        # Since it's newly wrapped, _is_vectorized should become True.
+        is_vectorized = getattr(mod.plain_func, "_is_vectorized", False)
+        print(f"plain_func vectorized?  {is_vectorized}")
+
+        assert is_vectorized is True, "Plain function was not auto-injected!"
+
+    finally:
+        # Cleanup module after test
+        del sys.modules[module_name]

vectorwave-0.2.4/src/tests/utils/test_replay_source.py

@@ -0,0 +1,140 @@
+import pytest
+import sys
+from unittest.mock import MagicMock, patch
+from vectorwave import vectorize, search_executions
+from vectorwave.utils.replayer import VectorWaveReplayer
+from vectorwave.models.db_config import WeaviateSettings
+
+# 1. Dummy function for testing
+@vectorize(unique_id="test_replay_tagging")
+def calc_add(a: int, b: int):
+    """Simple addition function for testing replay tags."""
+    return a + b
+
+@pytest.fixture
+def mock_replay_deps(monkeypatch):
+    """Mocks dependencies for Replay Source testing."""
+    # Mock Settings
+    mock_settings = WeaviateSettings(
+        EXECUTION_COLLECTION_NAME="VectorWaveExecutions",
+        GOLDEN_COLLECTION_NAME="VectorWaveGoldenDataset"
+    )
+    mock_get_settings = MagicMock(return_value=mock_settings)
+
+    # Mock Batch Manager (to verify logs)
+    mock_batch = MagicMock()
+    mock_batch.add_object = MagicMock()
+    mock_get_batch = MagicMock(return_value=mock_batch)
+
+    # Mock DB Client (for Replayer initialization)
+    mock_client = MagicMock()
+    mock_collection = MagicMock()
+    mock_client.collections.get.return_value = mock_collection
+    mock_get_client = MagicMock(return_value=mock_client)
+
+    # --- [수정] Patch dependencies where they are USED, not just defined ---
+
+    # 1. Patch for Replayer (vectorwave/utils/replayer.py)
+    monkeypatch.setattr("vectorwave.utils.replayer.get_cached_client", mock_get_client)
+    monkeypatch.setattr("vectorwave.utils.replayer.get_weaviate_settings", mock_get_settings)
+
+    # 2. Patch for Database (vectorwave/database/db.py) - 안전장치
+    monkeypatch.setattr("vectorwave.database.db.get_cached_client", mock_get_client)
+
+    # 3. Patch for Config (vectorwave/models/db_config.py) - 안전장치
+    monkeypatch.setattr("vectorwave.models.db_config.get_weaviate_settings", mock_get_settings)
+
+    # 4. Patch batch manager for Decorator & Tracer
+    monkeypatch.setattr("vectorwave.core.decorator.get_batch_manager", mock_get_batch)
+    monkeypatch.setattr("vectorwave.monitoring.tracer.get_batch_manager", mock_get_batch)
+
+    # 5. Patch search_executions in THIS test file
+    mock_search = MagicMock()
+    monkeypatch.setattr(sys.modules[__name__], "search_executions", mock_search)
+
+    return {
+        "batch": mock_batch,
+        "search": mock_search,
+        "client": mock_client
+    }
+
+def test_execution_source_tagging(mock_replay_deps):
+    """
+    Verification Scenario:
+    1. Realtime Execution -> Check if saved to DB as 'REALTIME'
+    2. Replay Execution -> Check if saved to DB as 'REPLAY'
+    """
+    mock_batch = mock_replay_deps["batch"]
+
+    # ---------------------------------------------------------
+    # Case 1: Realtime Execution
+    # ---------------------------------------------------------
+    print("\n🚀 1. Running Realtime Execution...")
+    calc_add(10, 20)
+
+    # Check if log was sent to BatchManager
+    assert mock_batch.add_object.called
+
+    # Get the latest call args
+    args, kwargs = mock_batch.add_object.call_args
+    props = kwargs['properties']
+
+    print(f"   [Log Check] Source: {props.get('exec_source')}")
+
+    # Verify exec_source is 'REALTIME'
+    assert props.get("exec_source") == "REALTIME"
+    assert props.get("status") == "SUCCESS"
+
+    # ---------------------------------------------------------
+    # Case 2: Replay Execution
+    # ---------------------------------------------------------
+    print("\n🔄 2. Running Replay...")
+
+    # Prepare dummy log for Replayer to fetch
+    dummy_log_obj = MagicMock()
+    dummy_log_obj.uuid = "old-uuid-123"
+    dummy_log_obj.properties = {
+        "function_name": "calc_add",
+        "a": 10,
+        "b": 20,
+        "return_value": "30",
+        "exec_source": "REALTIME"
+    }
+
+    # Replayer uses client.collections.get().query.fetch_objects()
+    mock_collection = mock_replay_deps["client"].collections.get.return_value
+    mock_collection.query.fetch_objects.return_value.objects = [dummy_log_obj]
+
+    # Also need to mock import_module since Replayer imports the function dynamically
+    with patch("vectorwave.utils.replayer.importlib.import_module") as mock_import:
+        mock_module = MagicMock()
+        # Set the function on the mock module
+        setattr(mock_module, "calc_add", calc_add)
+        mock_import.return_value = mock_module
+
+        replayer = VectorWaveReplayer()
+
+        # Reset batch mock to capture only replay log
+        mock_batch.add_object.reset_mock()
+
+        # Execute Replay
+        result = replayer.replay(
+            function_full_name="src.tests.utils.test_replay_source.calc_add",
+            limit=1
+        )
+
+    assert result['total'] > 0, "Replay should have executed at least 1 test."
+
+    # Check if new log was sent to BatchManager
+    assert mock_batch.add_object.called
+
+    # Get the latest call args (from Replay execution)
+    args, kwargs = mock_batch.add_object.call_args
+    replay_props = kwargs['properties']
+
+    print(f"   [Log Check] Source: {replay_props.get('exec_source')}")
+
+    # Verify exec_source is 'REPLAY'
+    assert replay_props.get("exec_source") == "REPLAY"
+
+    print("\n✅ All tests passed! Execution Source tagging is working.")

{vectorwave-0.2.2 → vectorwave-0.2.4}/src/vectorwave/__init__.py

@@ -1,5 +1,4 @@
 from .core.decorator import vectorize
-
 from .database.db import initialize_database
 from .database.db_search import search_functions, search_executions, search_errors_by_message, search_functions_hybrid
 from .monitoring.tracer import trace_span
@@ -9,6 +8,7 @@ from .utils.healer import VectorWaveHealer
 from .utils.replayer import VectorWaveReplayer
 from .utils.replayer_semantic import SemanticReplayer
 from .database.dataset import VectorWaveDatasetManager
+from .core.auto_injector import VectorWaveAutoInjector
 
 __all__ = [
     'vectorize',
@@ -24,5 +24,6 @@ __all__ = [
     'VectorWaveHealer',
     'VectorWaveReplayer',
     'SemanticReplayer',
-    'VectorWaveDatasetManager'
+    'VectorWaveDatasetManager',
+    'VectorWaveAutoInjector'
 ]

vectorwave-0.2.4/src/vectorwave/core/auto_injector.py

@@ -0,0 +1,100 @@
+import inspect
+import importlib
+import logging
+from functools import wraps
+from typing import Any, Optional
+
+# VectorWave Core Modules
+from .decorator import vectorize
+from ..monitoring.tracer import trace_span, current_tracer_var
+
+logger = logging.getLogger(__name__)
+
+def create_smart_wrapper(original_func, root_wrapper):
+    """
+    Creates a wrapper that switches behavior based on the Tracing Context.
+
+    Args:
+        original_func: The original function (used when acting as a Child Span).
+        root_wrapper: The wrapper generated by vectorize (used when acting as a Root Span, includes metadata).
+    """
+    @wraps(original_func)
+    def wrapper(*args, **kwargs):
+        # Check for existing tracer at runtime
+        tracer = current_tracer_var.get()
+
+        if tracer:
+            # [Case A] Parent trace exists -> Act as Child Span
+            # (Wrap original function with trace_span and execute)
+            return trace_span(original_func, capture_return_value=True)(*args, **kwargs)
+        else:
+            # [Case B] No parent trace -> Act as Root Span
+            # (Delegate to the already configured root_wrapper)
+            return root_wrapper(*args, **kwargs)
+
+    # Mark to prevent double injection
+    wrapper._is_vectorized = True
+    return wrapper
+
+
+class VectorWaveAutoInjector:
+    """
+    Scans specified modules or packages to automatically inject (Monkey Patch) VectorWave functionality.
+    """
+
+    # Global default configuration
+    _default_config = {}
+
+    @classmethod
+    def configure(cls, **kwargs):
+        """
+        Sets the default configuration to be applied to all inject calls.
+        """
+        cls._default_config.update(kwargs)
+        logger.info(f"⚙️ VectorWave AutoInjector Configured: {cls._default_config}")
+
+    @classmethod
+    def inject(cls, target_module_path: str, recursive: bool = False, **config):
+        """
+        Finds functions within a module and injects VectorWave functionality.
+        **Metadata registration (DB save or Pending) is performed immediately at this point.**
+        """
+        try:
+            module = importlib.import_module(target_module_path)
+        except ImportError as e:
+            logger.error(f"Failed to import module '{target_module_path}': {e}")
+            return None
+
+        # Merge configurations (Defaults < Individual Config)
+        final_config = cls._default_config.copy()
+        final_config.update(config)
+
+        logger.info(f"🌊 [AutoInjector] Injecting VectorWave into: {module.__name__}")
+
+        patched_count = 0
+
+        for name, obj in inspect.getmembers(module):
+            # Target only functions defined within the module
+            if inspect.isfunction(obj) and obj.__module__ == module.__name__:
+
+                # Skip if already processed
+                if getattr(obj, "_is_vectorized", False):
+                    continue
+
+                logger.info(f"  └─ Auto-wiring: {name}()")
+
+                # [Key Change] Call vectorize immediately at injection time to perform metadata registration!
+                # - If auto=False: Immediate DB save
+                # - If auto=True: Add to PENDING list
+                # The returned root_wrapper contains the execution logic (Root Span)
+                root_wrapper = vectorize(**final_config)(obj)
+
+                # Create smart wrapper to judge Context at runtime
+                smart_wrapper = create_smart_wrapper(obj, root_wrapper)
+
+                # Replace (Monkey Patching)
+                setattr(module, name, smart_wrapper)
+                patched_count += 1
+
+        logger.info(f"✨ Injection Complete. {patched_count} functions registered & auto-wired.")
+        return module

{vectorwave-0.2.2 → vectorwave-0.2.4}/src/vectorwave/core/decorator.py

@@ -11,6 +11,7 @@ from ..monitoring.tracer import trace_root, trace_span
 from ..utils.function_cache import function_cache_manager
 from ..utils.return_caching_utils import _check_and_return_cached_result
 from ..vectorizer.factory import get_vectorizer
+from ..utils.context import execution_source_context
 
 logger = logging.getLogger(__name__)
 
@@ -53,7 +54,7 @@ def vectorize(search_description: Optional[str] = None,
         func_uuid = generate_uuid5(func_identifier)
 
         # Prepare attributes to capture
-        final_attributes = ['function_uuid', 'team', 'priority', 'run_id']
+        final_attributes = ['function_uuid', 'team', 'priority', 'run_id', 'exec_source']
         if attributes_to_capture:
             for attr in attributes_to_capture:
                 if attr not in final_attributes:
@@ -145,7 +146,7 @@ def vectorize(search_description: Optional[str] = None,
             async def inner_wrapper(*args, **kwargs):
                 # Remove injected tags from kwargs before calling original func
                 clean_kwargs = {k: v for k, v in kwargs.items() if
-                                k not in valid_execution_tags and k != 'function_uuid'}
+                                k not in valid_execution_tags and k != 'function_uuid' and k != 'exec_source'}
                 return await func(*args, **clean_kwargs)
 
             @wraps(func)
@@ -157,8 +158,10 @@ def vectorize(search_description: Optional[str] = None,
                 full_kwargs = kwargs.copy()
                 full_kwargs.update(valid_execution_tags)
                 full_kwargs['function_uuid'] = func_uuid
+                full_kwargs['exec_source'] = execution_source_context.get()
                 return await inner_wrapper(*args, **full_kwargs)
 
+            outer_wrapper._is_vectorized = True
             return outer_wrapper
 
         else:  # Sync wrapper
@@ -167,7 +170,7 @@ def vectorize(search_description: Optional[str] = None,
             @wraps(func)
             def inner_wrapper(*args, **kwargs):
                 clean_kwargs = {k: v for k, v in kwargs.items() if
-                                k not in valid_execution_tags and k != 'function_uuid'}
+                                k not in valid_execution_tags and k != 'function_uuid' and k != 'exec_source'}
                 return func(*args, **clean_kwargs)
 
             @wraps(func)
@@ -179,8 +182,10 @@ def vectorize(search_description: Optional[str] = None,
                 full_kwargs = kwargs.copy()
                 full_kwargs.update(valid_execution_tags)
                 full_kwargs['function_uuid'] = func_uuid
+                full_kwargs['exec_source'] = execution_source_context.get()
                 return inner_wrapper(*args, **full_kwargs)
 
+            outer_wrapper._is_vectorized = True
             return outer_wrapper
 
-    return decorator
+    return decorator

{vectorwave-0.2.2 → vectorwave-0.2.4}/src/vectorwave/database/db.py

@@ -282,6 +282,11 @@ def create_execution_schema(client: weaviate.WeaviateClient, settings: WeaviateS
             name="return_value",
             data_type=wvc.DataType.TEXT,
             description="The JSON-serialized or str() representation of the function's return value"
+        ),
+        wvc.Property(
+            name="exec_source",
+            data_type=wvc.DataType.TEXT,
+            description="Source of execution: 'REALTIME' (User traffic) or 'REPLAY' (Regression Test)"
         )
     ]
 

{vectorwave-0.2.2 → vectorwave-0.2.4}/src/vectorwave/monitoring/tracer.py

@@ -15,6 +15,7 @@ from ..models.db_config import get_weaviate_settings, WeaviateSettings
 from .alert.factory import get_alerter
 from ..vectorizer.factory import get_vectorizer
 from ..database.db_search import check_semantic_drift
+from ..utils.context import execution_source_context
 
 # Create module-level logger
 logger = logging.getLogger(__name__)
@@ -137,7 +138,8 @@ def _create_span_properties(
         "status": status,
         "error_message": error_msg,
         "error_code": error_code,
-        "return_value": return_value_to_log
+        "return_value": return_value_to_log,
+        "exec_source": execution_source_context.get()
     }
 
     if tracer.settings.global_custom_values:

{vectorwave-0.2.2 → vectorwave-0.2.4}/src/vectorwave/search/execution_search.py

@@ -121,3 +121,34 @@ def find_by_trace_id(trace_id: str, limit: int = 100) -> List[Dict[str, Any]]:
         sort_ascending=True,  # Sort chronologically
         limit=limit
     )
+
+
+def find_replay_executions(
+        limit: int = 20,
+        status: Optional[str] = None,
+        function_name: Optional[str] = None
+) -> List[Dict[str, Any]]:
+    """
+    Searches specifically for logs generated during a Replay session.
+
+    Args:
+        limit: Max number of logs to retrieve.
+        status: Optional filter for 'SUCCESS' or 'ERROR'.
+        function_name: Optional filter for specific function name.
+    """
+    logger.info(f"\n--- Searching for REPLAY Executions (Status: {status}, Func: {function_name}) ---")
+
+    filters = {"exec_source": "REPLAY"}
+
+    if status:
+        filters["status"] = status
+
+    if function_name:
+        filters["function_name"] = function_name
+
+    return find_executions(
+        filters=filters,
+        sort_by="timestamp_utc",
+        sort_ascending=False,
+        limit=limit
+    )

vectorwave-0.2.4/src/vectorwave/utils/context.py

@@ -0,0 +1,4 @@
+from contextvars import ContextVar
+
+#default is realtime context
+execution_source_context: ContextVar[str] = ContextVar("execution_source", default="REALTIME")

{vectorwave-0.2.2 → vectorwave-0.2.4}/src/vectorwave/utils/replayer.py

@@ -13,6 +13,7 @@ import weaviate.classes.query as wvc_query
 from ..database.db import get_cached_client
 from ..models.db_config import get_weaviate_settings
 from ..monitoring.tracer import _mask_and_serialize
+from .context import execution_source_context
 
 logger = logging.getLogger(__name__)
 
@@ -78,7 +79,10 @@ class VectorWaveReplayer:
             # [FIX] Extract only valid arguments for the target function
             inputs = self._extract_inputs(raw_inputs, target_func)
 
+            token = None
             try:
+                token = execution_source_context.set("REPLAY")
+
                 # 3. Function Re-execution
                 if is_async_func:
                     actual_output = asyncio.run(target_func(**inputs))
@@ -127,6 +131,10 @@ class VectorWaveReplayer:
                     "traceback": traceback.format_exc()
                 })
 
+            finally:
+                if token:
+                    execution_source_context.reset(token)
+
         logger.info(f"Replay Finished. Passed: {results['passed']}, Failed: {results['failed']}")
         return results
 

{vectorwave-0.2.2 → vectorwave-0.2.4}/src/vectorwave/utils/replayer_semantic.py

@@ -6,6 +6,8 @@ import math
 import asyncio
 import inspect
 from typing import Any, Dict, List, Optional
+
+from .context import execution_source_context
 from ..core.llm.factory import get_llm_client
 
 import weaviate.classes.query as wvc_query
@@ -88,12 +90,16 @@ class SemanticReplayer(VectorWaveReplayer):
             inputs = self._extract_inputs(raw_inputs, target_func)
 
             try:
+                token = execution_source_context.set("REPLAY")
                 # 3. Function Re-execution
                 if is_async_func:
                     actual_output = asyncio.run(target_func(**inputs))
                 else:
                     actual_output = target_func(**inputs)
 
+                if token:
+                    execution_source_context.reset(token)
+
                 # 4. Result Validation (Semantic Comparison)
                 is_match, match_reason = self._compare_results_semantic(
                     expected_output,

{vectorwave-0.2.2 → vectorwave-0.2.4/src/vectorwave.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectorwave
-Version: 0.2.2
+Version: 0.2.4
 Summary: VectorWave: Seamless Auto-Vectorization Framework
 Author-email: junyeonggim <junyeonggim5@gmail.com>
 License-Expression: MIT
@@ -618,6 +618,40 @@ archiver.export_and_clear(
 {"messages": [{"role": "user", "content": "{\"price\": 100, \"tax\": 0.1}"}, {"role": "assistant", "content": "110.0"}]}
 ```
 
+## 🌊 Auto-Injection (Zero-Code Change Integration)
+
+You don't need to modify your business logic to use VectorWave. Use `VectorWaveAutoInjector` to inject functionality externally.
+
+### How to use
+
+1. **Configure Global Settings**: Set default values like `team`, `priority`, or `auto` (pending mode).
+2. **Inject Modules**: Specify the target module path string.
+
+```python
+from vectorwave import initialize_database, VectorWaveAutoInjector, generate_and_register_metadata
+
+# 1. Initialize DB
+initialize_database()
+
+# 2. Configure AutoInjector (Global Settings)
+VectorWaveAutoInjector.configure(
+    team="billing-team",
+    priority=1,
+    auto=True  # True: Collect metadata in memory (Pending), False: Save immediately to DB
+)
+
+# 3. Inject VectorWave into your module
+# (No need to add @vectorize decorators in 'my_service.payment' code!)
+VectorWaveAutoInjector.inject("my_service.payment")
+
+# 4. Register Metadata (If auto=True)
+generate_and_register_metadata()
+
+# 5. Run your business logic
+import my_service.payment
+my_service.payment.process_transaction()
+```
+
 ## 🤝 Contributing
 
 We welcome all forms of contributions, including bug reports, feature requests, and code contributions. Please refer to [CONTRIBUTING.md](https://www.google.com/search?q=httpsS://www.google.com/search%3Fq%3DCONTRIBUTING.md) for details.

{vectorwave-0.2.2 → vectorwave-0.2.4}/src/vectorwave.egg-info/SOURCES.txt

@@ -8,6 +8,8 @@ src/tests/conftest.py
 src/tests/batch/__init__.py
 src/tests/batch/test_batch.py
 src/tests/core/__init__.py
+src/tests/core/test_auto_injector.py
+src/tests/core/test_auto_injector_real.py
 src/tests/core/test_decorator.py
 src/tests/core/test_semantic_caching.py
 src/tests/core/llm/__init__.py
@@ -30,6 +32,7 @@ src/tests/search/__init__.py
 src/tests/search/test_execution_search.py
 src/tests/utils/__init__.py
 src/tests/utils/test_function_cahe.py
+src/tests/utils/test_replay_source.py
 src/tests/utils/test_replayer.py
 src/tests/utils/test_return_caching.py
 src/tests/utils/test_status.py
@@ -43,6 +46,7 @@ src/vectorwave.egg-info/top_level.txt
 src/vectorwave/batch/__init__.py
 src/vectorwave/batch/batch.py
 src/vectorwave/core/__init__.py
+src/vectorwave/core/auto_injector.py
 src/vectorwave/core/core.py
 src/vectorwave/core/decorator.py
 src/vectorwave/core/generator.py
@@ -74,6 +78,7 @@ src/vectorwave/search/execution_search.py
 src/vectorwave/search/extended_search.py
 src/vectorwave/search/rag_search.py
 src/vectorwave/utils/__init__.py
+src/vectorwave/utils/context.py
 src/vectorwave/utils/function_cache.py
 src/vectorwave/utils/healer.py
 src/vectorwave/utils/replayer.py