tracelify-sdk 0.1.0__tar.gz

tracelify_sdk-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tracelify Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tracelify_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: tracelify-sdk
+Version: 0.1.0
+Summary: Official Python SDK for Tracelify - Error Tracking and Performance Monitoring.
+Author-email: Tracelify Team <support@tracelify.io>
+Project-URL: Homepage, https://github.com/tracelify-io/tracelify-python
+Project-URL: Bug Tracker, https://github.com/tracelify-io/tracelify-python/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Dynamic: license-file
+
+# Tracelify Python SDK
+
+[![PyPI version](https://img.shields.io/pypi/v/tracelify-sdk.svg)](https://pypi.org/project/tracelify-sdk/)
+[![Python versions](https://img.shields.io/pypi/pyversions/tracelify-sdk.svg)](https://pypi.org/project/tracelify-sdk/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Official Python SDK for Tracelify - Effortless Error Tracking and Performance Monitoring for your Python applications.
+
+---
+
+## ⚡ Quick Start
+
+### 1. Install
+
+```bash
+pip install tracelify-sdk
+```
+
+### 2. Initialize
+
+Initialize the client with your DSN early in your application's entry point:
+
+```python
+from tracelify import Client
+
+# Initialize the client (automatically captures unhandled exceptions)
+client = Client("https://your-key@tracelify.io/project-id")
+```
+
+### 3. Capture Exceptions Manually
+
+```python
+try:
+    1 / 0
+except Exception as e:
+    client.capture_exception(e)
+```
+
+### 4. Enrich context
+
+```python
+# Set user context
+client.set_user({"id": "123", "email": "user@example.com"})
+
+# Set custom tags
+client.set_tag("environment", "production")
+
+# Add breadcrumbs for debugging
+client.add_breadcrumb("User clicked 'Submit' button")
+```
+
+---
+
+## 🛠️ Components
+
+- **Client**: Main interface to the SDK.
+- **Config**: Configuration and DSN parsing.
+- **Scope**: Manages user context, tags, and breadcrumbs.
+- **Transport**: Sends events asynchronously to the Tracelify server with automatic retries and exponential backoff.
+- **Handlers**: Automatic global exception capture for unhandled errors.
+
+---
+
+## ⚙️ Configuration
+
+The Tracelify SDK is designed to work with minimal configuration. Simply provide a valid DSN:
+
+| DSN Part | Description |
+| --- | --- |
+| `protocol` | http or https |
+| `key` | Your public authentication key |
+| `host` | Tracelify server hostname |
+| `port` | Server port (optional) |
+| `project_id`| Your project ID |
+
+Example DSN: `https://abcd1234@api.tracelify.io:8080/1`
+
+---
+
+## 🤝 Contributing
+
+We welcome contributions! Please check out our [CONTRIBUTING.md](CONTRIBUTING.md) and [CHANGELOG.md](CHANGELOG.md).
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

tracelify_sdk-0.1.0/README.md

@@ -0,0 +1,86 @@
+# Tracelify Python SDK
+
+[![PyPI version](https://img.shields.io/pypi/v/tracelify-sdk.svg)](https://pypi.org/project/tracelify-sdk/)
+[![Python versions](https://img.shields.io/pypi/pyversions/tracelify-sdk.svg)](https://pypi.org/project/tracelify-sdk/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Official Python SDK for Tracelify - Effortless Error Tracking and Performance Monitoring for your Python applications.
+
+---
+
+## ⚡ Quick Start
+
+### 1. Install
+
+```bash
+pip install tracelify-sdk
+```
+
+### 2. Initialize
+
+Initialize the client with your DSN early in your application's entry point:
+
+```python
+from tracelify import Client
+
+# Initialize the client (automatically captures unhandled exceptions)
+client = Client("https://your-key@tracelify.io/project-id")
+```
+
+### 3. Capture Exceptions Manually
+
+```python
+try:
+    1 / 0
+except Exception as e:
+    client.capture_exception(e)
+```
+
+### 4. Enrich context
+
+```python
+# Set user context
+client.set_user({"id": "123", "email": "user@example.com"})
+
+# Set custom tags
+client.set_tag("environment", "production")
+
+# Add breadcrumbs for debugging
+client.add_breadcrumb("User clicked 'Submit' button")
+```
+
+---
+
+## 🛠️ Components
+
+- **Client**: Main interface to the SDK.
+- **Config**: Configuration and DSN parsing.
+- **Scope**: Manages user context, tags, and breadcrumbs.
+- **Transport**: Sends events asynchronously to the Tracelify server with automatic retries and exponential backoff.
+- **Handlers**: Automatic global exception capture for unhandled errors.
+
+---
+
+## ⚙️ Configuration
+
+The Tracelify SDK is designed to work with minimal configuration. Simply provide a valid DSN:
+
+| DSN Part | Description |
+| --- | --- |
+| `protocol` | http or https |
+| `key` | Your public authentication key |
+| `host` | Tracelify server hostname |
+| `port` | Server port (optional) |
+| `project_id`| Your project ID |
+
+Example DSN: `https://abcd1234@api.tracelify.io:8080/1`
+
+---
+
+## 🤝 Contributing
+
+We welcome contributions! Please check out our [CONTRIBUTING.md](CONTRIBUTING.md) and [CHANGELOG.md](CHANGELOG.md).
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

tracelify_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tracelify-sdk"
+version = "0.1.0"
+authors = [
+  { name = "Tracelify Team", email = "support@tracelify.io" },
+]
+description = "Official Python SDK for Tracelify - Error Tracking and Performance Monitoring."
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "requests>=2.25.0",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/tracelify-io/tracelify-python"
+"Bug Tracker" = "https://github.com/tracelify-io/tracelify-python/issues"
+
+[tool.setuptools.packages.find]
+include = ["tracelify*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]

tracelify_sdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tracelify_sdk-0.1.0/tests/test_client.py

@@ -0,0 +1,68 @@
+import pytest
+from tracelify import Client, Config, ConfigError
+
+def test_config_parsing_valid():
+    """Test valid DSN parsing."""
+    dsn = "http://public_key@localhost:8000/1"
+    config = Config(dsn)
+    
+    assert config.protocol == "http"
+    assert config.public_key == "public_key"
+    assert config.host == "localhost"
+    assert config.port == 8000
+    assert config.project_id == "1"
+    assert config.get_endpoint() == "http://localhost:8000/api/1/events"
+
+def test_config_parsing_invalid():
+    """Test invalid DSN parsing raises ConfigError."""
+    # Missing public key
+    with pytest.raises(ConfigError):
+        Config("http://localhost:8000/1")
+        
+    # Missing host
+    with pytest.raises(ConfigError):
+        Config("http://key@/1")
+
+def test_client_init_success(monkeypatch):
+    """Test successful client initialization."""
+    # Mocking background worker start 
+    monkeypatch.setattr("tracelify.client.start_worker", lambda config: None)
+    
+    dsn = "http://key@localhost:8000/1"
+    client = Client(dsn)
+    
+    assert client.config.host == "localhost"
+    assert client.scope is not None
+
+def test_scope_context():
+    """Test that scope correctly accumulates context."""
+    from tracelify.scope import Scope
+    scope = Scope()
+    
+    scope.set_user({"id": "1"})
+    scope.set_tag("env", "prod")
+    scope.add_breadcrumb("test message")
+    
+    context = scope.get()
+    assert context["user"] == {"id": "1"}
+    assert context["tags"] == {"env": "prod"}
+    assert len(context["breadcrumbs"]) == 1
+    assert context["breadcrumbs"][0]["message"] == "test message"
+
+def test_event_model():
+    """Test that the event model dictionary conversion is correct."""
+    from tracelify.models import Event
+    from tracelify.utils import get_timestamp
+    
+    ts = get_timestamp()
+    event = Event(
+        project_id="123",
+        timestamp=ts,
+        error={"type": "ValueError", "message": "error msg", "stacktrace": "..."}
+    )
+    
+    d = event.to_dict()
+    assert d["project_id"] == "123"
+    assert d["timestamp"] == ts
+    assert d["error"]["type"] == "ValueError"
+    assert d["client"]["sdk"] == "tracelify-python"

tracelify_sdk-0.1.0/tracelify/__init__.py

@@ -0,0 +1,6 @@
+from .client import Client
+from .config import Config
+from .exceptions import TracelifyError, ConfigError, TransportError, APIError
+from .version import __version__
+
+__all__ = ["Client", "Config", "TracelifyError", "ConfigError", "TransportError", "APIError", "__version__"]

tracelify_sdk-0.1.0/tracelify/client.py

@@ -0,0 +1,103 @@
+import traceback
+import logging
+from typing import Any, Dict, Optional, List
+from .config import Config
+from .hub import set_client
+from .scope import Scope
+from .queue import event_queue
+from .worker import start_worker
+from .handlers import setup_global_handler
+from .utils import get_runtime_context, get_timestamp
+from .models import Event
+
+logger = logging.getLogger(__name__)
+
+class Client:
+    """
+    The main client for the Tracelify SDK.
+    
+    This class orchestrates exception capture, context management, and background event sending.
+    
+    Attributes:
+        config (Config): Configuration for the SDK.
+        scope (Scope): The current scope for user and tag context.
+    """
+
+    def __init__(self, dsn: str):
+        """
+        Initialize the Tracelify client.
+        
+        Args:
+            dsn: DSN of the project.
+        """
+        try:
+            self.config = Config(dsn)
+            self.scope = Scope()
+
+            # Global registration
+            set_client(self)
+
+            # Start background worker for asynchronous events
+            start_worker(self.config)
+
+            # Automatically capture unhandled exceptions
+            setup_global_handler()
+            
+            logger.info("Tracelify SDK client initialized successfully.")
+            
+        except Exception as e:
+            logger.error(f"Failed to initialize Tracelify SDK client: {e}")
+            raise
+
+    def capture_exception(self, error: Exception, stacktrace: Optional[str] = None):
+        """
+        Manually capture an exception and send it to Tracelify.
+        
+        Args:
+            error: The exception to capture.
+            stacktrace: Optional manual stacktrace string.
+        """
+        try:
+            if stacktrace is None:
+                tb = getattr(error, "__traceback__", None)
+                if tb is not None:
+                    stacktrace = "".join(traceback.format_exception(type(error), error, tb))
+                else:
+                    stacktrace = "".join(traceback.format_stack())
+
+            if not stacktrace:
+                stacktrace = "No stacktrace available"
+
+            # Prepare the event data
+            event_data = Event(
+                project_id=self.config.project_id,
+                timestamp=get_timestamp(),
+                error={
+                    "type": type(error).__name__,
+                    "message": str(error),
+                    "stacktrace": stacktrace
+                },
+                context=get_runtime_context(),
+                **self.scope.get()
+            )
+
+            # Send the event to the background queue
+            event_queue.put(event_data.to_dict())
+            logger.debug(f"Exception captured and queued: {type(error).__name__}")
+            
+        except Exception as e:
+            logger.error(f"Error while capturing exception: {e}")
+
+    # -------- CONTEXT METHODS --------
+
+    def set_user(self, user: Dict[str, Any]):
+        """Set the user for the current scope."""
+        self.scope.set_user(user)
+
+    def set_tag(self, key: str, value: str):
+        """Set a custom tag for context."""
+        self.scope.set_tag(key, value)
+
+    def add_breadcrumb(self, message: str, level: str = "info"):
+        """Add a breadcrumb to the current scope."""
+        self.scope.add_breadcrumb(message, level)

tracelify_sdk-0.1.0/tracelify/config.py

@@ -0,0 +1,60 @@
+from urllib.parse import urlparse
+from typing import Optional
+from .exceptions import ConfigError
+
+
+class Config:
+    """
+    Configuration for the Tracelify client.
+    
+    Attributes:
+        dsn (str): The Data Source Name for the project.
+        protocol (str): The protocol (http/https).
+        host (str): The host of the server.
+        port (int): The port of the server.
+        public_key (str): The public key for authentication.
+        project_id (str): The project ID to which events will be sent.
+    """
+
+    def __init__(self, dsn: str):
+        """
+        Initialize the config from a DSN string.
+        
+        Args:
+            dsn: DSN of the project (e.g., http://key@host:port/1)
+        
+        Raises:
+            ConfigError: If the DSN is invalid.
+        """
+        try:
+            parsed = urlparse(dsn)
+            self.dsn = dsn
+            self.protocol = parsed.scheme or "https"
+            self.host = parsed.hostname
+            self.port = parsed.port or (443 if self.protocol == "https" else 80)
+            self.public_key = parsed.username
+
+            if not self.host:
+                raise ConfigError("Invalid DSN: Missing host")
+            if not self.public_key:
+                raise ConfigError("Invalid DSN: Missing public key (username)")
+
+            path_parts = parsed.path.strip("/").split("/")
+            if not path_parts or not path_parts[0]:
+                self.project_id = "1"
+            else:
+                self.project_id = path_parts[0]
+                
+        except Exception as e:
+            if isinstance(e, ConfigError):
+                raise
+            raise ConfigError(f"Failed to parse DSN: {e}") from e
+
+    def get_endpoint(self) -> str:
+        """
+        Get the endpoint URL for sending events.
+        
+        Returns:
+            The complete URL for the events endpoint.
+        """
+        return f"{self.protocol}://{self.host}:{self.port}/api/{self.project_id}/events"

tracelify_sdk-0.1.0/tracelify/exceptions.py

@@ -0,0 +1,17 @@
+class TracelifyError(Exception):
+    """Base exception for all Tracelify SDK errors."""
+    pass
+
+class ConfigError(TracelifyError):
+    """Raised when there is a configuration error."""
+    pass
+
+class TransportError(TracelifyError):
+    """Raised when there is an issue with the underlying HTTP transport."""
+    pass
+
+class APIError(TracelifyError):
+    """Raised when the API returns an error response."""
+    def __init__(self, message, status_code=None):
+        super().__init__(message)
+        self.status_code = status_code

tracelify_sdk-0.1.0/tracelify/handlers.py

@@ -0,0 +1,30 @@
+import sys
+import traceback
+import logging
+from typing import Optional, Any
+from .hub import get_client
+
+logger = logging.getLogger(__name__)
+
+def setup_global_handler():
+    """Register the SDK with sys.excepthook to automatically capture unhandled exceptions."""
+    
+    def handle_exception(exc_type, exc_value, exc_traceback):
+        """Global exception handler callback."""
+        # Don't capture KeyboardInterrupt or system exit
+        if issubclass(exc_type, KeyboardInterrupt):
+            sys.__excepthook__(exc_type, exc_value, exc_traceback)
+            return
+
+        client = get_client()
+        if client:
+            try:
+                # Capture the exception
+                client.capture_exception(exc_value)
+            except Exception as e:
+                logger.error(f"Error while capturing exception in global handler: {e}")
+        
+        # Still call the original excepthook to avoid hiding the error from the user
+        sys.__excepthook__(exc_type, exc_value, exc_traceback)
+
+    sys.excepthook = handle_exception

tracelify_sdk-0.1.0/tracelify/hub.py

@@ -0,0 +1,13 @@
+from typing import Optional, Any
+
+# Global reference to the current client
+_current_client = None
+
+def set_client(client: Any) -> None:
+    """Set the globally available client."""
+    global _current_client
+    _current_client = client
+
+def get_client() -> Optional[Any]:
+    """Get the currently active client."""
+    return _current_client

tracelify_sdk-0.1.0/tracelify/models/__init__.py

@@ -0,0 +1,3 @@
+from .event import Event, User, Breadcrumb
+
+__all__ = ["Event", "User", "Breadcrumb"]

tracelify_sdk-0.1.0/tracelify/models/event.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass, field
+from typing import Dict, Any, List, Optional
+from ..utils import get_timestamp
+
+@dataclass
+class User:
+    id: Optional[str] = None
+    email: Optional[str] = None
+    username: Optional[str] = None
+    ip_address: Optional[str] = None
+
+@dataclass
+class Breadcrumb:
+    message: str
+    timestamp: str = field(default_factory=get_timestamp)
+    level: str = "info"
+    category: Optional[str] = None
+
+@dataclass
+class Event:
+    project_id: str
+    timestamp: str
+    error: Dict[str, Any]
+    client: Dict[str, str] = field(default_factory=lambda: {"sdk": "tracelify-python"})
+    user: Optional[Dict[str, Any]] = None
+    tags: Dict[str, str] = field(default_factory=dict)
+    breadcrumbs: List[Dict[str, Any]] = field(default_factory=list)
+    context: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "project_id": self.project_id,
+            "timestamp": self.timestamp,
+            "error": self.error,
+            "client": self.client,
+            "user": self.user,
+            "tags": self.tags,
+            "breadcrumbs": self.breadcrumbs,
+            "context": self.context,
+        }

tracelify_sdk-0.1.0/tracelify/queue.py

@@ -0,0 +1,5 @@
+import queue
+from typing import Any
+
+# Standard thread-safe queue for events
+event_queue = queue.Queue(maxsize=1000)

tracelify_sdk-0.1.0/tracelify/scope.py

@@ -0,0 +1,47 @@
+from typing import Dict, Any, List, Optional
+from .models.event import Breadcrumb
+
+class Scope:
+    """
+    Manages the current context (user, tags, breadcrumbs) for events.
+    """
+    
+    def __init__(self):
+        """Initialize an empty scope."""
+        self.user: Dict[str, Any] = {}
+        self.tags: Dict[str, str] = {}
+        self.breadcrumbs: List[Dict[str, Any]] = []
+
+    def set_user(self, user: Dict[str, Any]) -> None:
+        """Set user information for the current context."""
+        self.user = user
+
+    def set_tag(self, key: str, value: str) -> None:
+        """Set a tag for the current context."""
+        self.tags[key] = value
+
+    def add_breadcrumb(self, message: str, level: str = "info") -> None:
+        """Add a breadcrumb to the current context."""
+        breadcrumb = Breadcrumb(message=message, level=level)
+        self.breadcrumbs.append({
+            "message": breadcrumb.message,
+            "timestamp": breadcrumb.timestamp,
+            "level": breadcrumb.level
+        })
+        
+        # Keep only the last 100 breadcrumbs for memory safety
+        if len(self.breadcrumbs) > 100:
+            self.breadcrumbs.pop(0)
+
+    def get(self) -> Dict[str, Any]:
+        """
+        Get the current scope as a dictionary.
+        
+        Returns:
+            A dictionary containing user, tags, and breadcrumbs.
+        """
+        return {
+            "user": self.user,
+            "tags": self.tags,
+            "breadcrumbs": self.breadcrumbs[-20:] # Only include last 20 in the final event
+        }

tracelify_sdk-0.1.0/tracelify/transport.py

@@ -0,0 +1,68 @@
+import requests
+import logging
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+from typing import Any, Dict
+from .config import Config
+from .exceptions import TransportError
+
+logger = logging.getLogger(__name__)
+
+# Use a session with retries for efficiency and resilience
+_session = None
+
+def get_session():
+    """Get or create a requests session with retries."""
+    global _session
+    if _session is None:
+        _session = requests.Session()
+        
+        # Configure retry logic: 3 retries, exponential backoff, handle status codes 429, 500, 502, 503, 504
+        retries = Retry(
+            total=3,
+            backoff_factor=0.3,
+            status_forcelist=[429, 500, 502, 503, 504],
+            allowed_methods=["POST"]
+        )
+        _session.mount("http://", HTTPAdapter(max_retries=retries))
+        _session.mount("https://", HTTPAdapter(max_retries=retries))
+        
+    return _session
+
+def send_event(config: Config, data: Dict[str, Any]):
+    """
+    Send an event to the API using the provided configuration.
+    
+    Args:
+        config: The SDK configuration.
+        data: The event data to send.
+        
+    Raises:
+        TransportError: If the event fails to send.
+    """
+    try:
+        session = get_session()
+        response = session.post(
+            config.get_endpoint(),
+            json=data,
+            headers={
+                "X-Tracelify-Key": config.public_key,
+                "Content-Type": "application/json",
+                "User-Agent": "tracelify-python-sdk/0.1.0"
+            },
+            timeout=5
+        )
+        
+        # Raise an exception for 4xx or 5xx responses (not handled by Retry)
+        response.raise_for_status()
+        
+        logger.debug(f"Event sent successfully: {response.status_code}")
+        
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Failed to send event to Tracelify: {e}")
+        # We don't raise here to avoid crashing the user's application 
+        # unless it was a configuration error. We just log the failure.
+        pass
+    except Exception as e:
+        logger.error(f"Unexpected error in transport: {e}")
+        pass

tracelify_sdk-0.1.0/tracelify/utils.py

@@ -0,0 +1,25 @@
+import platform
+from datetime import datetime, timezone
+from typing import Dict, Any
+
+def get_runtime_context() -> Dict[str, Any]:
+    """
+    Get information about the system and runtime.
+    
+    Returns:
+        A dictionary containing OS and Python runtime information.
+    """
+    return {
+        "os": platform.system(),
+        "runtime": "python",
+        "python_version": platform.python_version()
+    }
+
+def get_timestamp() -> str:
+    """
+    Get current UTC timestamp in ISO 8601 format.
+    
+    Returns:
+        ISO format timestamp (UTC).
+    """
+    return datetime.now(timezone.utc).isoformat()

tracelify_sdk-0.1.0/tracelify/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

tracelify_sdk-0.1.0/tracelify/worker.py

@@ -0,0 +1,38 @@
+import threading
+import logging
+from .queue import event_queue
+from .transport import send_event
+from .config import Config
+
+logger = logging.getLogger(__name__)
+
+def start_worker(config: Config) -> None:
+    """
+    Start a background thread to send events from the queue to the API.
+    
+    Args:
+        config: SDK configuration for the transport.
+    """
+
+    def worker():
+        """Background worker loop."""
+        while True:
+            try:
+                # Wait for an event to be added to the queue
+                event = event_queue.get()
+                if event is None: # Shutdown signal
+                    break
+                    
+                # Send the event via transport
+                send_event(config, event)
+                
+            except Exception as e:
+                logger.error(f"Error in background worker: {e}")
+            finally:
+                # Always mark the task as done
+                event_queue.task_done()
+
+    # Create a daemon thread so it doesn't block process exit
+    thread = threading.Thread(target=worker, daemon=True, name="tracelify-worker")
+    thread.start()
+    logger.debug("Background worker thread started.")

tracelify_sdk-0.1.0/tracelify_sdk.egg-info/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: tracelify-sdk
+Version: 0.1.0
+Summary: Official Python SDK for Tracelify - Error Tracking and Performance Monitoring.
+Author-email: Tracelify Team <support@tracelify.io>
+Project-URL: Homepage, https://github.com/tracelify-io/tracelify-python
+Project-URL: Bug Tracker, https://github.com/tracelify-io/tracelify-python/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Dynamic: license-file
+
+# Tracelify Python SDK
+
+[![PyPI version](https://img.shields.io/pypi/v/tracelify-sdk.svg)](https://pypi.org/project/tracelify-sdk/)
+[![Python versions](https://img.shields.io/pypi/pyversions/tracelify-sdk.svg)](https://pypi.org/project/tracelify-sdk/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Official Python SDK for Tracelify - Effortless Error Tracking and Performance Monitoring for your Python applications.
+
+---
+
+## ⚡ Quick Start
+
+### 1. Install
+
+```bash
+pip install tracelify-sdk
+```
+
+### 2. Initialize
+
+Initialize the client with your DSN early in your application's entry point:
+
+```python
+from tracelify import Client
+
+# Initialize the client (automatically captures unhandled exceptions)
+client = Client("https://your-key@tracelify.io/project-id")
+```
+
+### 3. Capture Exceptions Manually
+
+```python
+try:
+    1 / 0
+except Exception as e:
+    client.capture_exception(e)
+```
+
+### 4. Enrich context
+
+```python
+# Set user context
+client.set_user({"id": "123", "email": "user@example.com"})
+
+# Set custom tags
+client.set_tag("environment", "production")
+
+# Add breadcrumbs for debugging
+client.add_breadcrumb("User clicked 'Submit' button")
+```
+
+---
+
+## 🛠️ Components
+
+- **Client**: Main interface to the SDK.
+- **Config**: Configuration and DSN parsing.
+- **Scope**: Manages user context, tags, and breadcrumbs.
+- **Transport**: Sends events asynchronously to the Tracelify server with automatic retries and exponential backoff.
+- **Handlers**: Automatic global exception capture for unhandled errors.
+
+---
+
+## ⚙️ Configuration
+
+The Tracelify SDK is designed to work with minimal configuration. Simply provide a valid DSN:
+
+| DSN Part | Description |
+| --- | --- |
+| `protocol` | http or https |
+| `key` | Your public authentication key |
+| `host` | Tracelify server hostname |
+| `port` | Server port (optional) |
+| `project_id`| Your project ID |
+
+Example DSN: `https://abcd1234@api.tracelify.io:8080/1`
+
+---
+
+## 🤝 Contributing
+
+We welcome contributions! Please check out our [CONTRIBUTING.md](CONTRIBUTING.md) and [CHANGELOG.md](CHANGELOG.md).
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

tracelify_sdk-0.1.0/tracelify_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+pyproject.toml
+tests/test_client.py
+tracelify/__init__.py
+tracelify/client.py
+tracelify/config.py
+tracelify/exceptions.py
+tracelify/handlers.py
+tracelify/hub.py
+tracelify/queue.py
+tracelify/scope.py
+tracelify/transport.py
+tracelify/utils.py
+tracelify/version.py
+tracelify/worker.py
+tracelify/models/__init__.py
+tracelify/models/event.py
+tracelify_sdk.egg-info/PKG-INFO
+tracelify_sdk.egg-info/SOURCES.txt
+tracelify_sdk.egg-info/dependency_links.txt
+tracelify_sdk.egg-info/requires.txt
+tracelify_sdk.egg-info/top_level.txt

tracelify_sdk-0.1.0/tracelify_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tracelify_sdk-0.1.0/tracelify_sdk.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.25.0

tracelify_sdk-0.1.0/tracelify_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+tracelify