tracepulse 0.1.0__tar.gz

tracepulse-0.1.0/LICENSE

@@ -0,0 +1,6 @@
+MIT License
+
+Copyright (c) 2026 Akshay Bajpai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files...

tracepulse-0.1.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: tracepulse
+Version: 0.1.0
+Summary: Execution tracing & performance observability for Python services
+Author: Akshay Bajpai
+Project-URL: Homepage, https://github.com/yourusername/tracepulse
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: loguru
+Dynamic: license-file
+
+# Tracepulse
+
+![PyPI](https://img.shields.io/pypi/v/tracepulse)
+![License](https://img.shields.io/badge/license-MIT-blue)
+![Downloads](https://img.shields.io/pypi/dm/tracepulse)
+
+Tracepulse is a lightweight execution tracing and performance observability layer designed for backend and AI workloads where runtime visibility is critical.
+
+It provides structured execution telemetry across synchronous and asynchronous code paths with minimal overhead.
+
+---
+
+## Why Tracepulse Exists
+
+Modern AI and service pipelines execute complex multi-step logic, often without runtime transparency.
+
+Tracepulse introduces deterministic tracing at the function boundary, enabling:
+
+- Runtime performance visibility
+- Failure surface detection
+- Observability without external infra
+
+---
+
+## Features
+
+- Sync + Async tracing
+- Structured execution logs
+- Failure telemetry capture
+- Duration measurement (ms precision)
+- Loguru-backed logging
+- Zero configuration setup
+
+---
+
+## Installation
+
+pip install tracepulse
+
+---
+
+## Usage
+
+from tracepulse import trace
+
+@trace
+def compute():
+    return sum(range(1_000_000))
+
+compute()
+
+---
+
+## Async Example
+
+import asyncio
+from tracepulse import trace
+
+@trace
+async def fetch():
+    await asyncio.sleep(1)
+
+asyncio.run(fetch())
+
+---
+
+## Philosophy
+
+Tracepulse is built on the principle that observability should exist at the code boundary — not only in external monitoring systems.
+
+It is intentionally minimal, extensible, and production-safe.
+
+---
+
+## License
+
+MIT

tracepulse-0.1.0/README.md

@@ -0,0 +1,77 @@
+# Tracepulse
+
+![PyPI](https://img.shields.io/pypi/v/tracepulse)
+![License](https://img.shields.io/badge/license-MIT-blue)
+![Downloads](https://img.shields.io/pypi/dm/tracepulse)
+
+Tracepulse is a lightweight execution tracing and performance observability layer designed for backend and AI workloads where runtime visibility is critical.
+
+It provides structured execution telemetry across synchronous and asynchronous code paths with minimal overhead.
+
+---
+
+## Why Tracepulse Exists
+
+Modern AI and service pipelines execute complex multi-step logic, often without runtime transparency.
+
+Tracepulse introduces deterministic tracing at the function boundary, enabling:
+
+- Runtime performance visibility
+- Failure surface detection
+- Observability without external infra
+
+---
+
+## Features
+
+- Sync + Async tracing
+- Structured execution logs
+- Failure telemetry capture
+- Duration measurement (ms precision)
+- Loguru-backed logging
+- Zero configuration setup
+
+---
+
+## Installation
+
+pip install tracepulse
+
+---
+
+## Usage
+
+from tracepulse import trace
+
+@trace
+def compute():
+    return sum(range(1_000_000))
+
+compute()
+
+---
+
+## Async Example
+
+import asyncio
+from tracepulse import trace
+
+@trace
+async def fetch():
+    await asyncio.sleep(1)
+
+asyncio.run(fetch())
+
+---
+
+## Philosophy
+
+Tracepulse is built on the principle that observability should exist at the code boundary — not only in external monitoring systems.
+
+It is intentionally minimal, extensible, and production-safe.
+
+---
+
+## License
+
+MIT

tracepulse-0.1.0/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tracepulse"
+version = "0.1.0"
+description = "Execution tracing & performance observability for Python services"
+authors = [{ name="Akshay Bajpai" }]
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = ["loguru"]
+
+[project.urls]
+Homepage = "https://github.com/yourusername/tracepulse"

tracepulse-0.1.0/setup.cfg

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

tracepulse-0.1.0/tracepulse/__init__.py

@@ -0,0 +1,3 @@
+from .tracer import trace
+
+__all__ = ["trace"]

tracepulse-0.1.0/tracepulse/logger.py

@@ -0,0 +1,29 @@
+from loguru import logger
+import sys
+from pathlib import Path
+
+
+LOG_DIR = Path("logs")
+LOG_DIR.mkdir(exist_ok=True)
+
+
+logger.remove()
+
+logger.add(
+    sys.stdout,
+    format=(
+        "<green>{time:YYYY-MM-DD HH:mm:ss}</green> | "
+        "<level>{level}</level> | "
+        "{extra} | "
+        "{message}"
+    ),
+    level="INFO"
+)
+
+logger.add(
+    LOG_DIR / "tracepulse.log",
+    rotation="10 MB",
+    retention="7 days",
+    compression="zip",
+    serialize=True
+)

tracepulse-0.1.0/tracepulse/tracer.py

@@ -0,0 +1,83 @@
+import time
+import functools
+import asyncio
+from .logger import logger
+
+
+def trace(fn):
+    """
+    Execution tracing decorator supporting sync and async functions.
+    Captures runtime duration, structured logs, and failure telemetry.
+    """
+
+    if asyncio.iscoroutinefunction(fn):
+
+        @functools.wraps(fn)
+        async def async_wrapper(*args, **kwargs):
+
+            start = time.perf_counter()
+            fn_name = fn.__name__
+
+            logger.bind(function=fn_name).info("Execution started")
+
+            try:
+                result = await fn(*args, **kwargs)
+
+                duration = (time.perf_counter() - start) * 1000
+
+                logger.bind(
+                    function=fn_name,
+                    duration_ms=round(duration, 2)
+                ).success("Execution completed")
+
+                return result
+
+            except Exception as e:
+
+                duration = (time.perf_counter() - start) * 1000
+
+                logger.bind(
+                    function=fn_name,
+                    duration_ms=round(duration, 2),
+                    error=str(e)
+                ).error("Execution failed")
+
+                raise
+
+        return async_wrapper
+
+    else:
+
+        @functools.wraps(fn)
+        def sync_wrapper(*args, **kwargs):
+
+            start = time.perf_counter()
+            fn_name = fn.__name__
+
+            logger.bind(function=fn_name).info("Execution started")
+
+            try:
+                result = fn(*args, **kwargs)
+
+                duration = (time.perf_counter() - start) * 1000
+
+                logger.bind(
+                    function=fn_name,
+                    duration_ms=round(duration, 2)
+                ).success("Execution completed")
+
+                return result
+
+            except Exception as e:
+
+                duration = (time.perf_counter() - start) * 1000
+
+                logger.bind(
+                    function=fn_name,
+                    duration_ms=round(duration, 2),
+                    error=str(e)
+                ).error("Execution failed")
+
+                raise
+
+        return sync_wrapper

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

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: tracepulse
+Version: 0.1.0
+Summary: Execution tracing & performance observability for Python services
+Author: Akshay Bajpai
+Project-URL: Homepage, https://github.com/yourusername/tracepulse
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: loguru
+Dynamic: license-file
+
+# Tracepulse
+
+![PyPI](https://img.shields.io/pypi/v/tracepulse)
+![License](https://img.shields.io/badge/license-MIT-blue)
+![Downloads](https://img.shields.io/pypi/dm/tracepulse)
+
+Tracepulse is a lightweight execution tracing and performance observability layer designed for backend and AI workloads where runtime visibility is critical.
+
+It provides structured execution telemetry across synchronous and asynchronous code paths with minimal overhead.
+
+---
+
+## Why Tracepulse Exists
+
+Modern AI and service pipelines execute complex multi-step logic, often without runtime transparency.
+
+Tracepulse introduces deterministic tracing at the function boundary, enabling:
+
+- Runtime performance visibility
+- Failure surface detection
+- Observability without external infra
+
+---
+
+## Features
+
+- Sync + Async tracing
+- Structured execution logs
+- Failure telemetry capture
+- Duration measurement (ms precision)
+- Loguru-backed logging
+- Zero configuration setup
+
+---
+
+## Installation
+
+pip install tracepulse
+
+---
+
+## Usage
+
+from tracepulse import trace
+
+@trace
+def compute():
+    return sum(range(1_000_000))
+
+compute()
+
+---
+
+## Async Example
+
+import asyncio
+from tracepulse import trace
+
+@trace
+async def fetch():
+    await asyncio.sleep(1)
+
+asyncio.run(fetch())
+
+---
+
+## Philosophy
+
+Tracepulse is built on the principle that observability should exist at the code boundary — not only in external monitoring systems.
+
+It is intentionally minimal, extensible, and production-safe.
+
+---
+
+## License
+
+MIT

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

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+tracepulse/__init__.py
+tracepulse/logger.py
+tracepulse/tracer.py
+tracepulse.egg-info/PKG-INFO
+tracepulse.egg-info/SOURCES.txt
+tracepulse.egg-info/dependency_links.txt
+tracepulse.egg-info/requires.txt
+tracepulse.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+loguru

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

@@ -0,0 +1 @@
+tracepulse