veghe-sdk 1.0.0__tar.gz

veghe_sdk-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Veghe.ro
+
+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.

veghe_sdk-1.0.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: veghe-sdk
+Version: 1.0.0
+Summary: Veghe SDK for Python — minimal, dependency-free error reporting to Veghe.ro
+Author-email: "Veghe.ro" <admin@veghe.ro>
+License: MIT
+Project-URL: Homepage, https://veghe.ro/en/features/error-tracking
+Project-URL: Documentation, https://veghe.ro/docs/error-tracking/
+Project-URL: Dashboard, https://i.veghe.ro
+Keywords: error-tracking,monitoring,exceptions,veghe,crash-reporting
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: Software Development :: Bug Tracking
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# veghe-sdk
+
+Minimal, dependency-free error reporting for Python apps, sending to
+[Veghe.ro](https://veghe.ro) error tracking. One module, stdlib only.
+
+## Install
+
+```bash
+pip install veghe-sdk
+```
+
+## Use
+
+```python
+import veghe_sdk
+
+veghe_sdk.init(
+    "https://<key>@i.veghe.ro/<project-id>",   # your project DSN
+    release="myapp@1.4.2",                     # enables regression detection
+    environment="production",
+)
+
+# Uncaught exceptions are now reported automatically. You can also:
+veghe_sdk.capture_exception()                       # inside an except block
+veghe_sdk.capture_message("webhook lagging", level="warning")
+veghe_sdk.set_tag("region", "eu-central")
+veghe_sdk.set_user({"email": "user@example.com"})
+
+# For short-lived scripts, flush before exit:
+veghe_sdk.flush()
+```
+
+Events are sent on background threads and failures are swallowed —
+monitoring never breaks the app it watches.
+
+Get a DSN by creating an error project in your
+[Veghe dashboard](https://i.veghe.ro) under **Errors**. Grouped issues,
+stack traces with code context, releases and regression detection,
+threshold alerts and JS source maps are documented in the
+[error tracking docs](https://veghe.ro/docs/error-tracking/).
+
+Veghe also speaks the Sentry ingestion protocol, so official Sentry SDKs
+(any platform) work against the same DSN.

veghe_sdk-1.0.0/README.md

@@ -0,0 +1,43 @@
+# veghe-sdk
+
+Minimal, dependency-free error reporting for Python apps, sending to
+[Veghe.ro](https://veghe.ro) error tracking. One module, stdlib only.
+
+## Install
+
+```bash
+pip install veghe-sdk
+```
+
+## Use
+
+```python
+import veghe_sdk
+
+veghe_sdk.init(
+    "https://<key>@i.veghe.ro/<project-id>",   # your project DSN
+    release="myapp@1.4.2",                     # enables regression detection
+    environment="production",
+)
+
+# Uncaught exceptions are now reported automatically. You can also:
+veghe_sdk.capture_exception()                       # inside an except block
+veghe_sdk.capture_message("webhook lagging", level="warning")
+veghe_sdk.set_tag("region", "eu-central")
+veghe_sdk.set_user({"email": "user@example.com"})
+
+# For short-lived scripts, flush before exit:
+veghe_sdk.flush()
+```
+
+Events are sent on background threads and failures are swallowed —
+monitoring never breaks the app it watches.
+
+Get a DSN by creating an error project in your
+[Veghe dashboard](https://i.veghe.ro) under **Errors**. Grouped issues,
+stack traces with code context, releases and regression detection,
+threshold alerts and JS source maps are documented in the
+[error tracking docs](https://veghe.ro/docs/error-tracking/).
+
+Veghe also speaks the Sentry ingestion protocol, so official Sentry SDKs
+(any platform) work against the same DSN.

veghe_sdk-1.0.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "veghe-sdk"
+version = "1.0.0"
+description = "Veghe SDK for Python — minimal, dependency-free error reporting to Veghe.ro"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "Veghe.ro", email = "admin@veghe.ro" }]
+requires-python = ">=3.8"
+keywords = ["error-tracking", "monitoring", "exceptions", "veghe", "crash-reporting"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Topic :: System :: Monitoring",
+    "Topic :: Software Development :: Bug Tracking",
+]
+
+[project.urls]
+Homepage = "https://veghe.ro/en/features/error-tracking"
+Documentation = "https://veghe.ro/docs/error-tracking/"
+Dashboard = "https://i.veghe.ro"
+
+[tool.setuptools]
+py-modules = ["veghe_sdk"]

veghe_sdk-1.0.0/setup.cfg

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

veghe_sdk-1.0.0/veghe_sdk.egg-info/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: veghe-sdk
+Version: 1.0.0
+Summary: Veghe SDK for Python — minimal, dependency-free error reporting to Veghe.ro
+Author-email: "Veghe.ro" <admin@veghe.ro>
+License: MIT
+Project-URL: Homepage, https://veghe.ro/en/features/error-tracking
+Project-URL: Documentation, https://veghe.ro/docs/error-tracking/
+Project-URL: Dashboard, https://i.veghe.ro
+Keywords: error-tracking,monitoring,exceptions,veghe,crash-reporting
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: Software Development :: Bug Tracking
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# veghe-sdk
+
+Minimal, dependency-free error reporting for Python apps, sending to
+[Veghe.ro](https://veghe.ro) error tracking. One module, stdlib only.
+
+## Install
+
+```bash
+pip install veghe-sdk
+```
+
+## Use
+
+```python
+import veghe_sdk
+
+veghe_sdk.init(
+    "https://<key>@i.veghe.ro/<project-id>",   # your project DSN
+    release="myapp@1.4.2",                     # enables regression detection
+    environment="production",
+)
+
+# Uncaught exceptions are now reported automatically. You can also:
+veghe_sdk.capture_exception()                       # inside an except block
+veghe_sdk.capture_message("webhook lagging", level="warning")
+veghe_sdk.set_tag("region", "eu-central")
+veghe_sdk.set_user({"email": "user@example.com"})
+
+# For short-lived scripts, flush before exit:
+veghe_sdk.flush()
+```
+
+Events are sent on background threads and failures are swallowed —
+monitoring never breaks the app it watches.
+
+Get a DSN by creating an error project in your
+[Veghe dashboard](https://i.veghe.ro) under **Errors**. Grouped issues,
+stack traces with code context, releases and regression detection,
+threshold alerts and JS source maps are documented in the
+[error tracking docs](https://veghe.ro/docs/error-tracking/).
+
+Veghe also speaks the Sentry ingestion protocol, so official Sentry SDKs
+(any platform) work against the same DSN.

veghe_sdk-1.0.0/veghe_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+LICENSE
+README.md
+pyproject.toml
+veghe_sdk.py
+veghe_sdk.egg-info/PKG-INFO
+veghe_sdk.egg-info/SOURCES.txt
+veghe_sdk.egg-info/dependency_links.txt
+veghe_sdk.egg-info/top_level.txt

veghe_sdk-1.0.0/veghe_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

veghe_sdk-1.0.0/veghe_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+veghe_sdk

veghe_sdk-1.0.0/veghe_sdk.py

@@ -0,0 +1,177 @@
+"""Veghe SDK for Python — minimal, dependency-free error reporting.
+
+Usage:
+    import veghe_sdk
+    veghe_sdk.init(
+        "https://<key>@i.veghe.ro/<project-id>",
+        release="myapp@1.4.2",
+        environment="production",
+    )
+    # uncaught exceptions are now reported automatically, or:
+    veghe_sdk.capture_exception()
+    veghe_sdk.capture_message("payment webhook lagging", level="warning")
+
+Single file, stdlib only. Events are sent on a background thread and
+never raise: monitoring must not break the app it watches.
+Download: https://i.veghe.ro/app/static/sdk/veghe_sdk.py
+"""
+import json
+import linecache
+import sys
+import threading
+import traceback
+import urllib.request
+import uuid
+from datetime import datetime, timezone
+
+__version__ = "1.0.0"
+
+_config = None
+_previous_excepthook = None
+
+
+def init(dsn, release=None, environment=None, tags=None, install_excepthook=True, timeout=5):
+    """Configure the SDK. dsn: https://<key>@<host>/<project-id>."""
+    global _config, _previous_excepthook
+    scheme, rest = dsn.split("://", 1)
+    key, host_part = rest.split("@", 1)
+    host, project_id = host_part.rsplit("/", 1)
+    _config = {
+        "endpoint": f"{scheme}://{host}/api/{project_id}/store/?sentry_key={key.split(':')[0]}",
+        "release": release,
+        "environment": environment,
+        "tags": dict(tags or {}),
+        "user": None,
+        "timeout": timeout,
+    }
+    if install_excepthook and _previous_excepthook is None:
+        _previous_excepthook = sys.excepthook
+        sys.excepthook = _excepthook
+
+
+def set_tag(key, value):
+    if _config is not None:
+        _config["tags"][str(key)] = str(value)
+
+
+def set_user(user):
+    """user: dict with any of id, username, email, ip_address."""
+    if _config is not None:
+        _config["user"] = user
+
+
+def capture_exception(exc=None, tags=None):
+    """Report an exception (defaults to the one currently being handled)."""
+    if _config is None:
+        return None
+    if exc is not None:
+        exc_info = (type(exc), exc, exc.__traceback__)
+    else:
+        exc_info = sys.exc_info()
+    if exc_info[0] is None:
+        return None
+    event = _base_event(tags)
+    event["exception"] = {"values": [_exception_value(*exc_info)]}
+    return _send(event)
+
+
+def capture_message(message, level="info", tags=None):
+    if _config is None:
+        return None
+    event = _base_event(tags)
+    event["message"] = str(message)
+    event["level"] = level
+    return _send(event)
+
+
+def flush(timeout=5):
+    """Wait for in-flight sends (call before exiting short-lived scripts)."""
+    for thread in list(_threads):
+        thread.join(timeout)
+
+
+def _excepthook(exc_type, exc_value, exc_tb):
+    try:
+        if _config is not None:
+            event = _base_event(None)
+            event["level"] = "fatal"
+            event["exception"] = {"values": [_exception_value(exc_type, exc_value, exc_tb)]}
+            _send(event)
+            flush(_config["timeout"])
+    finally:
+        (_previous_excepthook or sys.__excepthook__)(exc_type, exc_value, exc_tb)
+
+
+def _base_event(tags):
+    event = {
+        "event_id": uuid.uuid4().hex,
+        "timestamp": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "platform": "python",
+        "level": "error",
+        "sdk": {"name": "veghe-python", "version": __version__},
+        "server_name": _safe_hostname(),
+        "tags": {**_config["tags"], **(tags or {})},
+    }
+    if _config["release"]:
+        event["release"] = _config["release"]
+    if _config["environment"]:
+        event["environment"] = _config["environment"]
+    if _config["user"]:
+        event["user"] = _config["user"]
+    return event
+
+
+def _exception_value(exc_type, exc_value, exc_tb):
+    frames = []
+    for frame, lineno in traceback.walk_tb(exc_tb):
+        filename = frame.f_code.co_filename
+        in_app = not ("site-packages" in filename or "dist-packages" in filename
+                      or filename.startswith(sys.prefix))
+        frames.append({
+            "filename": filename,
+            "function": frame.f_code.co_name,
+            "module": frame.f_globals.get("__name__"),
+            "lineno": lineno,
+            "context_line": linecache.getline(filename, lineno).rstrip() or None,
+            "pre_context": [linecache.getline(filename, l).rstrip()
+                            for l in range(max(1, lineno - 5), lineno)],
+            "post_context": [linecache.getline(filename, l).rstrip()
+                             for l in range(lineno + 1, lineno + 6)],
+            "in_app": in_app,
+        })
+    return {
+        "type": getattr(exc_type, "__name__", str(exc_type)),
+        "value": str(exc_value),
+        "stacktrace": {"frames": frames} if frames else None,
+    }
+
+
+def _safe_hostname():
+    try:
+        import socket
+        return socket.gethostname()
+    except Exception:
+        return None
+
+
+_threads = []
+
+
+def _send(event):
+    def _post():
+        try:
+            request = urllib.request.Request(
+                _config["endpoint"],
+                data=json.dumps(event, default=str).encode("utf-8"),
+                headers={"Content-Type": "application/json"},
+            )
+            urllib.request.urlopen(request, timeout=_config["timeout"]).read()
+        except Exception:
+            pass  # never let monitoring break the app
+
+    thread = threading.Thread(target=_post, daemon=True)
+    thread.start()
+    _threads.append(thread)
+    if len(_threads) > 32:
+        del _threads[:-32]
+    return event["event_id"]