vectorwave 0.2.8__tar.gz → 0.2.9__tar.gz

vectorwave-0.2.9/PKG-INFO

@@ -0,0 +1,255 @@
+Metadata-Version: 2.4
+Name: vectorwave
+Version: 0.2.9
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Rust
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Requires-Dist: weaviate-client>=4.0.0
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: sentence-transformers
+Requires-Dist: requests
+Requires-Dist: openai
+Requires-Dist: pygithub
+Requires-Dist: schedule
+License-File: LICENSE
+License-File: NOTICE
+Summary: VectorWave: Seamless Auto-Vectorization Framework
+Author-email: junyeonggim <junyeonggim5@gmail.com>
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Repository, https://github.com/cozymori/vectorwave
+
+Need more information? Visit [here](https://cozymori.github.io/vectorwave-docs/)
+
+# VectorWave
+![Star](https://badgen.net/github/stars/cozymori/vectorwave)
+![Release](https://badgen.net/github/release/cozymori/vectorwave)
+![Tag](https://badgen.net/github/tag/cozymori/vectorwave)
+![Commit](https://badgen.net/github/last-commit/cozymori/vectorwave)
+![Contributors](https://badgen.net/github/contributors/cozymori/vectorwave)
+![OpenPrs](https://badgen.net/github/open-prs/cozymori/vectorwave)
+![MergedPrs](https://badgen.net/github/merged-prs/cozymori/vectorwave)
+![Checks](https://badgen.net/github/checks/cozymori/vectorwave)
+![Pypi](https://badgen.net/pypi/v/vectorwave)
+<br>**Seamless Auto-Vectorization Framework**
+
+We transform volatile data that disappears the moment code is executed into a Searchable and Reusable permanent knowledge asset.
+
+### Requirements
+
+* **Python**: 3.10 ~ 3.13
+* **Docker**: Required to run the Weaviate database.
+* (Optional) **OpenAI API Key**: Required for AI auto-documentation and high-performance embedding.
+
+### How to reach us
+
+Have questions or found a bug? Please join our community.
+
+* **GitHub Issues**: [https://github.com/cozymori/vectorwave/issues](https://github.com/cozymori/vectorwave/issues)
+
+### Contributors
+[See the contributors of vectorwave](https://github.com/Cozymori/VectorWave/graphs/contributors)<br>
+VectorWave is an open-source project and we welcome your contributions.
+Please refer to [CONTRIBUTING.md](https://www.google.com/search?q=https://github.com/cozymori/vectorwave/blob/main/CONTRIBUTING.md) in the GitHub repository.
+
+---
+
+## 🚀 What is VectorWave?
+
+**VectorWave** is a unified framework designed to solve the "Efficiency vs. Reliability" dilemma in LLM-integrated applications. It introduces a new paradigm of **Execution-Level Semantic Optimization** combined with **Autonomous Self-Healing**.
+
+Unlike conventional semantic caching tools that primarily focus on text similarity, **VectorWave** captures the entire **Function Execution Context**. It creates a permanent "Golden Dataset" from your successful executions and uses it to:
+
+1.  **Slash Costs**: Serve cached results for semantically similar inputs, bypassing expensive computations.
+2.  **Fix Bugs**: Automatically diagnose runtime errors and generate GitHub PRs using LLM.
+3.  **Monitor Quality**: Detect when user inputs start drifting away from known patterns (Semantic Drift).
+
+##  Architecture
+
+VectorWave operates as a transparent layer between your application and the LLM/Infrastructure, handling everything from vectorization to GitOps automation.
+
+![VectorWave Architecture](./docs_kr/images/module_arch.png)
+
+### Core Components
+* **Optimization Engine**: Intercepts function calls to check for semantic cache hits using HNSW indexes.
+* **Trace Context Manager**: Collects execution logs, inputs, and outputs without modifying your code structure.
+* **Self-Healing Pipeline**: An autonomous agent that wakes up on errors, diagnoses the root cause, and submits patches.
+
+## 😊 Quick Start
+
+You can attach VectorWave to any Python function using a simple decorator.
+
+### 1. Prerequisites (Start Vector DB)
+
+VectorWave requires a Vector Database (Weaviate) to store execution contexts.
+Create a `docker-compose.yml` file and start the service:
+
+```yaml
+# docker-compose.yml
+version: '3.4'
+services:
+  weaviate:
+    command:
+    - --host
+    - 0.0.0.0
+    - --port
+    - '8080'
+    - --scheme
+    - http
+    image: semitechnologies/weaviate:1.26.1
+    ports:
+    - 8080:8080
+    - 50051:50051
+    restart: on-failure:0
+    environment:
+      QUERY_DEFAULTS_LIMIT: 25
+      AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: 'true'
+      PERSISTENCE_DATA_PATH: '/var/lib/weaviate'
+      DEFAULT_VECTORIZER_MODULE: 'none'
+      ENABLE_MODULES: 'text2vec-openai,generative-openai'
+      CLUSTER_HOSTNAME: 'node1'
+
+```
+
+Run the container:
+
+```bash
+docker-compose up -d
+
+```
+
+### 2. Install VectorWave
+
+```bash
+pip install vectorwave
+
+```
+
+### 3. Basic Usage (Semantic Caching)
+
+Now, apply the `@vectorize` decorator to your functions.
+
+```python
+import time
+from vectorwave import vectorize, initialize_database
+
+# 1. (Optional) Set up your OpenAI Key for vectorization
+# os.environ["OPENAI_API_KEY"] = "sk-..."
+
+initialize_database()
+
+# 2. Just add the @vectorize decorator!
+@vectorize(semantic_cache=True, cache_threshold=0.95, auto=True)
+def expensive_llm_task(query: str):
+    # Simulate a slow and expensive API call
+    time.sleep(2) 
+    return f"Processed result for: {query}"
+
+# First call: Runs the function (Cache Miss) -> Took 2.0s
+print(expensive_llm_task("How do I fix a Python bug?"))
+
+# Second call: Returns from Weaviate DB (Cache Hit) -> Took 0.02s!
+# Even if the query is slightly different but semantically same.
+print(expensive_llm_task("Tell me how to debug Python code."))
+
+```
+
+### 4. Self-Healing in Action
+
+When your code breaks, VectorWave actively fixes it.
+
+```python
+# Suppose this function has a bug (ZeroDivisionError)
+@vectorize(auto=True)
+def risky_calculation(a, b):
+    return a / b
+
+# Triggering an error
+risky_calculation(10, 0) 
+
+```
+
+**What happens next?**
+
+1. **Detection**: The `AutoHealerBot` detects the `ZeroDivisionError`.
+2. **Diagnosis**: It retrieves the source code and error stack trace.
+3. **Fix**: It uses an LLM to generate a patch (adding `try-except` or input validation).
+4. **Action**: A **Pull Request** is automatically created in your GitHub repository.
+
+![VectorWave Healer Architecture](./docs_kr/images/self_healing.png)
+
+
+##  Key Features
+
+### ⚡ Optimization Engine (Semantic Caching)
+
+Don't pay for the same computation twice. VectorWave uses **Weaviate** vector database to store and retrieve function results based on meaning, not just exact string matching.
+
+* **Latency**: Reduced from seconds to milliseconds.
+* **Cost**: Up to 90% reduction in LLM token usage.
+
+![VectorWave Semantic Caching Architecture](./docs_kr/images/detail_arch.png)
+
+
+###  Self-Healing & GitOps
+
+VectorWave doesn't just log errors; it acts on them.
+
+* **Automated Root Cause Analysis (RCA)** using RAG.
+* **GitOps Integration**: Generates actual code fixes and pushes them to a new branch.
+* **Cooldown Mechanism**: Prevents spamming PRs for the same error.
+
+###  Semantic Drift Radar
+
+Detect when your users are asking things your model wasn't designed for.
+
+* **Anomaly Detection**: Calculates the distance between new queries and your "Golden Dataset".
+* **Alerting**: Sends notifications (e.g., Discord) when drift exceeds the threshold (default 0.25).
+
+![VectorWave Drift Architecture](./docs_kr/images/semantic_drift.png)
+
+
+##  How does it work?
+
+Unlike traditional Key-Value caching (e.g., Redis), VectorWave understands **Context**.
+
+1. **Vectorization**: It converts function arguments into high-dimensional vectors using OpenAI or HuggingFace models.
+2. **Search**: It performs an Approximate Nearest Neighbor (ANN) search in the vector store.
+3. **Decision**:
+* If a neighbor is found within the `threshold` -> **Return Cached Result**.
+* If not -> **Execute Function** -> **Async Log to DB**.
+
+
+
+##  Performance Benchmark
+
+| Metric | Direct Execution | With VectorWave | Improvement |
+| --- | --- | --- | --- |
+| **Latency (Hit)** | ~2.5s (LLM API) | **~0.02s** | **125x Faster** |
+| **Cost (Hit)** | $0.03 / call | **$0.00** | **100% Savings** |
+| **Reliability** | Manual Fix Required | **Auto-PR Created** | **Autonomous** |
+
+##  Feature Comparison
+
+Why choose VectorWave over traditional semantic caches?
+
+| Feature | Traditional Tools (e.g., GPTCache) | **VectorWave** |
+| :--- | :---: | :---: |
+| **Semantic Caching** | O (Text-based) | **O (Execution Context)** |
+| **Self-Healing (Auto-Fix)** | X | **O (Autonomous)** |
+| **GitOps (Auto-PR)** | X | **O (Seamless)** |
+| **Semantic Drift Detection** | X | **O (Drift Radar)** |
+| **Zero-Config Setup** | △ (Setup Required) | **O (Decorator)** |
+
+## 😍 Contributing
+
+We are extremely open to contributions! Whether it's a new vectorizer, a better healing prompt, or just a typo fix.
+Please check our [Contribution Guide](./Contributing.md).
+

vectorwave-0.2.9/Readme.md

@@ -0,0 +1,226 @@
+Need more information? Visit [here](https://cozymori.github.io/vectorwave-docs/)
+
+# VectorWave
+![Star](https://badgen.net/github/stars/cozymori/vectorwave)
+![Release](https://badgen.net/github/release/cozymori/vectorwave)
+![Tag](https://badgen.net/github/tag/cozymori/vectorwave)
+![Commit](https://badgen.net/github/last-commit/cozymori/vectorwave)
+![Contributors](https://badgen.net/github/contributors/cozymori/vectorwave)
+![OpenPrs](https://badgen.net/github/open-prs/cozymori/vectorwave)
+![MergedPrs](https://badgen.net/github/merged-prs/cozymori/vectorwave)
+![Checks](https://badgen.net/github/checks/cozymori/vectorwave)
+![Pypi](https://badgen.net/pypi/v/vectorwave)
+<br>**Seamless Auto-Vectorization Framework**
+
+We transform volatile data that disappears the moment code is executed into a Searchable and Reusable permanent knowledge asset.
+
+### Requirements
+
+* **Python**: 3.10 ~ 3.13
+* **Docker**: Required to run the Weaviate database.
+* (Optional) **OpenAI API Key**: Required for AI auto-documentation and high-performance embedding.
+
+### How to reach us
+
+Have questions or found a bug? Please join our community.
+
+* **GitHub Issues**: [https://github.com/cozymori/vectorwave/issues](https://github.com/cozymori/vectorwave/issues)
+
+### Contributors
+[See the contributors of vectorwave](https://github.com/Cozymori/VectorWave/graphs/contributors)<br>
+VectorWave is an open-source project and we welcome your contributions.
+Please refer to [CONTRIBUTING.md](https://www.google.com/search?q=https://github.com/cozymori/vectorwave/blob/main/CONTRIBUTING.md) in the GitHub repository.
+
+---
+
+## 🚀 What is VectorWave?
+
+**VectorWave** is a unified framework designed to solve the "Efficiency vs. Reliability" dilemma in LLM-integrated applications. It introduces a new paradigm of **Execution-Level Semantic Optimization** combined with **Autonomous Self-Healing**.
+
+Unlike conventional semantic caching tools that primarily focus on text similarity, **VectorWave** captures the entire **Function Execution Context**. It creates a permanent "Golden Dataset" from your successful executions and uses it to:
+
+1.  **Slash Costs**: Serve cached results for semantically similar inputs, bypassing expensive computations.
+2.  **Fix Bugs**: Automatically diagnose runtime errors and generate GitHub PRs using LLM.
+3.  **Monitor Quality**: Detect when user inputs start drifting away from known patterns (Semantic Drift).
+
+##  Architecture
+
+VectorWave operates as a transparent layer between your application and the LLM/Infrastructure, handling everything from vectorization to GitOps automation.
+
+![VectorWave Architecture](./docs_kr/images/module_arch.png)
+
+### Core Components
+* **Optimization Engine**: Intercepts function calls to check for semantic cache hits using HNSW indexes.
+* **Trace Context Manager**: Collects execution logs, inputs, and outputs without modifying your code structure.
+* **Self-Healing Pipeline**: An autonomous agent that wakes up on errors, diagnoses the root cause, and submits patches.
+
+## 😊 Quick Start
+
+You can attach VectorWave to any Python function using a simple decorator.
+
+### 1. Prerequisites (Start Vector DB)
+
+VectorWave requires a Vector Database (Weaviate) to store execution contexts.
+Create a `docker-compose.yml` file and start the service:
+
+```yaml
+# docker-compose.yml
+version: '3.4'
+services:
+  weaviate:
+    command:
+    - --host
+    - 0.0.0.0
+    - --port
+    - '8080'
+    - --scheme
+    - http
+    image: semitechnologies/weaviate:1.26.1
+    ports:
+    - 8080:8080
+    - 50051:50051
+    restart: on-failure:0
+    environment:
+      QUERY_DEFAULTS_LIMIT: 25
+      AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: 'true'
+      PERSISTENCE_DATA_PATH: '/var/lib/weaviate'
+      DEFAULT_VECTORIZER_MODULE: 'none'
+      ENABLE_MODULES: 'text2vec-openai,generative-openai'
+      CLUSTER_HOSTNAME: 'node1'
+
+```
+
+Run the container:
+
+```bash
+docker-compose up -d
+
+```
+
+### 2. Install VectorWave
+
+```bash
+pip install vectorwave
+
+```
+
+### 3. Basic Usage (Semantic Caching)
+
+Now, apply the `@vectorize` decorator to your functions.
+
+```python
+import time
+from vectorwave import vectorize, initialize_database
+
+# 1. (Optional) Set up your OpenAI Key for vectorization
+# os.environ["OPENAI_API_KEY"] = "sk-..."
+
+initialize_database()
+
+# 2. Just add the @vectorize decorator!
+@vectorize(semantic_cache=True, cache_threshold=0.95, auto=True)
+def expensive_llm_task(query: str):
+    # Simulate a slow and expensive API call
+    time.sleep(2) 
+    return f"Processed result for: {query}"
+
+# First call: Runs the function (Cache Miss) -> Took 2.0s
+print(expensive_llm_task("How do I fix a Python bug?"))
+
+# Second call: Returns from Weaviate DB (Cache Hit) -> Took 0.02s!
+# Even if the query is slightly different but semantically same.
+print(expensive_llm_task("Tell me how to debug Python code."))
+
+```
+
+### 4. Self-Healing in Action
+
+When your code breaks, VectorWave actively fixes it.
+
+```python
+# Suppose this function has a bug (ZeroDivisionError)
+@vectorize(auto=True)
+def risky_calculation(a, b):
+    return a / b
+
+# Triggering an error
+risky_calculation(10, 0) 
+
+```
+
+**What happens next?**
+
+1. **Detection**: The `AutoHealerBot` detects the `ZeroDivisionError`.
+2. **Diagnosis**: It retrieves the source code and error stack trace.
+3. **Fix**: It uses an LLM to generate a patch (adding `try-except` or input validation).
+4. **Action**: A **Pull Request** is automatically created in your GitHub repository.
+
+![VectorWave Healer Architecture](./docs_kr/images/self_healing.png)
+
+
+##  Key Features
+
+### ⚡ Optimization Engine (Semantic Caching)
+
+Don't pay for the same computation twice. VectorWave uses **Weaviate** vector database to store and retrieve function results based on meaning, not just exact string matching.
+
+* **Latency**: Reduced from seconds to milliseconds.
+* **Cost**: Up to 90% reduction in LLM token usage.
+
+![VectorWave Semantic Caching Architecture](./docs_kr/images/detail_arch.png)
+
+
+###  Self-Healing & GitOps
+
+VectorWave doesn't just log errors; it acts on them.
+
+* **Automated Root Cause Analysis (RCA)** using RAG.
+* **GitOps Integration**: Generates actual code fixes and pushes them to a new branch.
+* **Cooldown Mechanism**: Prevents spamming PRs for the same error.
+
+###  Semantic Drift Radar
+
+Detect when your users are asking things your model wasn't designed for.
+
+* **Anomaly Detection**: Calculates the distance between new queries and your "Golden Dataset".
+* **Alerting**: Sends notifications (e.g., Discord) when drift exceeds the threshold (default 0.25).
+
+![VectorWave Drift Architecture](./docs_kr/images/semantic_drift.png)
+
+
+##  How does it work?
+
+Unlike traditional Key-Value caching (e.g., Redis), VectorWave understands **Context**.
+
+1. **Vectorization**: It converts function arguments into high-dimensional vectors using OpenAI or HuggingFace models.
+2. **Search**: It performs an Approximate Nearest Neighbor (ANN) search in the vector store.
+3. **Decision**:
+* If a neighbor is found within the `threshold` -> **Return Cached Result**.
+* If not -> **Execute Function** -> **Async Log to DB**.
+
+
+
+##  Performance Benchmark
+
+| Metric | Direct Execution | With VectorWave | Improvement |
+| --- | --- | --- | --- |
+| **Latency (Hit)** | ~2.5s (LLM API) | **~0.02s** | **125x Faster** |
+| **Cost (Hit)** | $0.03 / call | **$0.00** | **100% Savings** |
+| **Reliability** | Manual Fix Required | **Auto-PR Created** | **Autonomous** |
+
+##  Feature Comparison
+
+Why choose VectorWave over traditional semantic caches?
+
+| Feature | Traditional Tools (e.g., GPTCache) | **VectorWave** |
+| :--- | :---: | :---: |
+| **Semantic Caching** | O (Text-based) | **O (Execution Context)** |
+| **Self-Healing (Auto-Fix)** | X | **O (Autonomous)** |
+| **GitOps (Auto-PR)** | X | **O (Seamless)** |
+| **Semantic Drift Detection** | X | **O (Drift Radar)** |
+| **Zero-Config Setup** | △ (Setup Required) | **O (Decorator)** |
+
+## 😍 Contributing
+
+We are extremely open to contributions! Whether it's a new vectorizer, a better healing prompt, or just a typo fix.
+Please check our [Contribution Guide](./Contributing.md).

{vectorwave-0.2.8 → vectorwave-0.2.9}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "maturin"
 
 [project]
 name = "vectorwave"
-version = "0.2.8"
+version = "0.2.09"
 authors = [
     { name = "junyeonggim", email = "junyeonggim5@gmail.com" },
 ]
@@ -30,7 +30,9 @@ dependencies = [
     "pydantic-settings>=2.0.0",
     "sentence-transformers",
     "requests",
-    "openai"
+    "openai",
+    "PyGithub",
+    "schedule"
 ]
 
 [project.urls]

{vectorwave-0.2.8 → vectorwave-0.2.9}/src/vectorwave/core/decorator.py

@@ -1,5 +1,6 @@
 import inspect
 import logging
+import os
 from functools import wraps
 from typing import List, Optional, Dict, Any
 
@@ -12,6 +13,7 @@ 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
+from ..utils.path_utils import get_repo_root_and_relative_path # New import
 
 logger = logging.getLogger(__name__)
 
@@ -102,8 +104,22 @@ def vectorize(search_description: Optional[str] = None,
             docstring = inspect.getdoc(func) or ""
             source_code = inspect.getsource(func)
 
+            try:
+                abs_file_path = os.path.abspath(inspect.getsourcefile(func))
+                repo_root, relative_file_path = get_repo_root_and_relative_path(abs_file_path)
+                if relative_file_path:
+                    file_path = relative_file_path
+                else:
+                    file_path = abs_file_path # Fallback to absolute path if not in a git repo
+                    logger.warning(f"Function '{function_name}' is not in a Git repository. "
+                                   f"PR creation might fail for absolute path: {file_path}")
+            except Exception as e:
+                file_path = ""
+                logger.error(f"Failed to determine file path for '{function_name}': {e}")
+
             static_properties = {
                 "function_name": function_name,
+                "file_path": file_path,
                 "module_name": module_name,
                 "docstring": docstring,
                 "source_code": source_code,

{vectorwave-0.2.8 → vectorwave-0.2.9}/src/vectorwave/database/db.py

@@ -100,6 +100,7 @@ def create_vectorwave_schema(client: weaviate.WeaviateClient, settings: Weaviate
         wvc.Property(name="source_code", data_type=wvc.DataType.TEXT),
         wvc.Property(name="search_description", data_type=wvc.DataType.TEXT),
         wvc.Property(name="sequence_narrative", data_type=wvc.DataType.TEXT),
+        wvc.Property(name="file_path",data_type=wvc.DataType.TEXT),
     ]
 
     custom_properties = []

{vectorwave-0.2.8 → vectorwave-0.2.9}/src/vectorwave/models/db_config.py

@@ -41,11 +41,18 @@ class WeaviateSettings(BaseSettings):
 
     CUSTOM_PROPERTIES_FILE_PATH: str = ".weaviate_properties"
     FAILURE_MAPPING_FILE_PATH: str = ".vectorwave_errors.json"
+    IGNORE_ERROR_FILE_PATH: str = ".vtwignore"
+
+    GITHUB_TOKEN: Optional[str] = None
+    GITHUB_REPO_NAME: Optional[str] = None
+    GITHUB_BASE_BRANCH: str = "main"
 
     custom_properties: Optional[Dict[str, Dict[str, Any]]] = None
     global_custom_values: Optional[Dict[str, Any]] = None
     failure_mapping: Optional[Dict[str, str]] = None
 
+    ignored_error_codes: Set[str] = set()
+
     ALERTER_STRATEGY: str = "none"
     ALERTER_WEBHOOK_URL: Optional[str] = None
     ALERTER_MIN_LEVEL: str = "ERROR"
@@ -128,6 +135,17 @@ def get_weaviate_settings() -> WeaviateSettings:
     elif error_file_path:
         logger.info(f"Note: Failure mapping file not found at '{error_file_path}'. Skipping.")
 
+    ignore_file_path = settings.IGNORE_ERROR_FILE_PATH
+    if ignore_file_path and os.path.exists(ignore_file_path):
+        logger.info(f"Loading ignore error codes from '{ignore_file_path}'...")
+        try:
+            with open(ignore_file_path, 'r', encoding='utf-8') as f:
+                codes = {line.strip() for line in f if line.strip() and not line.startswith('#')}
+                settings.ignored_error_codes = codes
+                logger.info(f"Loaded {len(codes)} ignored error codes.")
+        except Exception as e:
+            logger.warning(f"Could not read '{ignore_file_path}': {e}")
+
     try:
         settings.sensitive_keys = {
             key.strip().lower()

{vectorwave-0.2.8 → vectorwave-0.2.9}/src/vectorwave/monitoring/tracer.py

@@ -289,9 +289,15 @@ def trace_span(
                             return_value_log = str(processed_result)
 
                 except Exception as e:
-                    status = "ERROR"
                     error_msg = traceback.format_exc()
                     error_code = _determine_error_code(tracer, e)
+
+                    if error_code in tracer.settings.ignored_error_codes:
+                        status = "FAILURE"
+                        tracer.alert_sent = True
+                    else:
+                        status = "ERROR"
+
                     span_properties = _create_span_properties(
                         tracer, func, start_time, status, error_msg, error_code, captured_attributes,
                         my_span_id=my_span_id, parent_span_id=parent_span_id,
@@ -401,9 +407,15 @@ def trace_span(
                             return_value_log = str(processed_result)
 
                 except Exception as e:
-                    status = "ERROR"
                     error_msg = traceback.format_exc()
                     error_code = _determine_error_code(tracer, e)
+
+                    if error_code in tracer.settings.ignored_error_codes:
+                        status = "FAILURE"
+                        tracer.alert_sent = True
+                    else:
+                        status = "ERROR"
+
                     span_properties = _create_span_properties(
                         tracer, func, start_time, status, error_msg, error_code, captured_attributes,
                         my_span_id=my_span_id, parent_span_id=parent_span_id,