sentry-logger 0.1.0__tar.gz

sentry_logger-0.1.0/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: sentry-logger
+Version: 0.1.0
+Summary: Push logs from your Python app to the Sentry dashboard — AI-powered service health monitoring
+Author-email: Sentry <support@sentrylabs.live>
+License-Expression: MIT
+Project-URL: Homepage, https://sentrylabs.live
+Project-URL: Repository, https://github.com/moiz-frost/sentry
+Project-URL: Bug Tracker, https://github.com/moiz-frost/sentry/issues
+Keywords: logging,monitoring,observability,sentry,dashboard,devtools
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Logging
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Sentry Logger SDK (Python)
+
+Push logs from your Python app to the Sentry dashboard.
+
+## Installation
+
+```bash
+pip install sentry-logger
+# or from the repo:
+pip install ./sdk/python
+```
+
+## Quick Start — CLI + Browser OAuth
+
+```bash
+sentry-logger init --app-name "my-service" --dsn "http://localhost:9000"
+```
+
+What happens:
+
+1. CLI requests a device session from the backend
+2. Browser opens your sign-in page
+3. Sign in with Google — your app is registered and an API key is created
+4. CLI polls and stores credentials in `~/.sentry_logger/config.json`
+
+Check the currently linked app:
+
+```bash
+sentry-logger status
+```
+
+## SDK Usage
+
+```python
+from sentry_logger import init
+
+# Reads api_key and dsn from ~/.sentry_logger/config.json
+init()
+
+import logging
+logging.info("Hello from my app")
+logging.error("Something went wrong")
+```
+
+Explicit configuration:
+
+```python
+from sentry_logger import init
+
+init(
+    api_key="sk_...",
+    dsn="http://localhost:9000",   # your backend URL
+)
+```
+
+## Environment Variables
+
+| Variable           | Default                  | Description                     |
+|--------------------|--------------------------|--------------------------------|
+| `LOGSENTRY_URL`    | `http://localhost:9000`  | Backend ingest URL base        |
+
+## FastAPI Example
+
+```python
+import logging
+from fastapi import FastAPI
+from sentry_logger import init
+
+app = FastAPI()
+
+@app.on_event("startup")
+def setup_logging() -> None:
+    init()
+    logging.getLogger(__name__).info("Sentry SDK initialized")
+```
+
+## Configuration Reference
+
+| Parameter                | Default | Description                                           |
+|--------------------------|---------|-------------------------------------------------------|
+| `api_key`                | —       | API key (`sk_...`). If omitted, loaded from CLI config |
+| `dsn`                    | —       | Ingest URL. Falls back to `LOGSENTRY_URL` env or `http://localhost:8001` |
+| `batch_size`             | `50`    | Send logs when buffer reaches this size               |
+| `flush_interval_seconds` | `5.0`   | Auto-flush buffer after this many seconds             |
+
+## Log Format
+
+The SDK formats logs in the standard Python logging format. The backend parses:
+
+```
+2024-01-01 10:00:00,123 [INFO] [ServiceName]: Log message here
+```
+
+The `ServiceName` in brackets is used to group logs by service in the dashboard.
+Use Python logger names to map to service names:
+
+```python
+logger = logging.getLogger("PaymentService")
+logger.info("Payment processed")
+```

sentry_logger-0.1.0/README.md

@@ -0,0 +1,100 @@
+# Sentry Logger SDK (Python)
+
+Push logs from your Python app to the Sentry dashboard.
+
+## Installation
+
+```bash
+pip install sentry-logger
+# or from the repo:
+pip install ./sdk/python
+```
+
+## Quick Start — CLI + Browser OAuth
+
+```bash
+sentry-logger init --app-name "my-service" --dsn "http://localhost:9000"
+```
+
+What happens:
+
+1. CLI requests a device session from the backend
+2. Browser opens your sign-in page
+3. Sign in with Google — your app is registered and an API key is created
+4. CLI polls and stores credentials in `~/.sentry_logger/config.json`
+
+Check the currently linked app:
+
+```bash
+sentry-logger status
+```
+
+## SDK Usage
+
+```python
+from sentry_logger import init
+
+# Reads api_key and dsn from ~/.sentry_logger/config.json
+init()
+
+import logging
+logging.info("Hello from my app")
+logging.error("Something went wrong")
+```
+
+Explicit configuration:
+
+```python
+from sentry_logger import init
+
+init(
+    api_key="sk_...",
+    dsn="http://localhost:9000",   # your backend URL
+)
+```
+
+## Environment Variables
+
+| Variable           | Default                  | Description                     |
+|--------------------|--------------------------|--------------------------------|
+| `LOGSENTRY_URL`    | `http://localhost:9000`  | Backend ingest URL base        |
+
+## FastAPI Example
+
+```python
+import logging
+from fastapi import FastAPI
+from sentry_logger import init
+
+app = FastAPI()
+
+@app.on_event("startup")
+def setup_logging() -> None:
+    init()
+    logging.getLogger(__name__).info("Sentry SDK initialized")
+```
+
+## Configuration Reference
+
+| Parameter                | Default | Description                                           |
+|--------------------------|---------|-------------------------------------------------------|
+| `api_key`                | —       | API key (`sk_...`). If omitted, loaded from CLI config |
+| `dsn`                    | —       | Ingest URL. Falls back to `LOGSENTRY_URL` env or `http://localhost:8001` |
+| `batch_size`             | `50`    | Send logs when buffer reaches this size               |
+| `flush_interval_seconds` | `5.0`   | Auto-flush buffer after this many seconds             |
+
+## Log Format
+
+The SDK formats logs in the standard Python logging format. The backend parses:
+
+```
+2024-01-01 10:00:00,123 [INFO] [ServiceName]: Log message here
+```
+
+The `ServiceName` in brackets is used to group logs by service in the dashboard.
+Use Python logger names to map to service names:
+
+```python
+logger = logging.getLogger("PaymentService")
+logger.info("Payment processed")
+```

sentry_logger-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sentry-logger"
+version = "0.1.0"
+description = "Push logs from your Python app to the Sentry dashboard — AI-powered service health monitoring"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [{ name = "Sentry", email = "support@sentrylabs.live" }]
+keywords = ["logging", "monitoring", "observability", "sentry", "dashboard", "devtools"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Software Development :: Libraries",
+  "Topic :: System :: Logging",
+  "Topic :: System :: Monitoring",
+]
+
+[project.urls]
+Homepage = "https://sentrylabs.live"
+Repository = "https://github.com/moiz-frost/sentry"
+"Bug Tracker" = "https://github.com/moiz-frost/sentry/issues"
+
+[project.scripts]
+sentry-logger = "sentry_logger.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["sentry_logger*"]

sentry_logger-0.1.0/sentry_logger/__init__.py

@@ -0,0 +1,70 @@
+"""
+Sentry Logger SDK - Push logs from your Python app to the Sentry dashboard.
+"""
+from __future__ import annotations
+
+from typing import Optional
+
+from .handler import SentryLogHandler
+from .config import SentryLoggerConfig
+from .local_config import load_local_config, resolve_dsn
+
+__all__ = ["SentryLogHandler", "SentryLoggerConfig", "init"]
+
+
+def init(
+    api_key: Optional[str] = None,
+    dsn: Optional[str] = None,
+    batch_size: int = 50,
+    flush_interval_seconds: float = 5.0,
+) -> SentryLogHandler:
+    """
+    Initialize Sentry Logger and attach it to the root Python logger.
+
+    Args:
+        api_key: Your Sentry API key.  If omitted, reads from the local config
+                 file written by ``sentry-logger init`` (~/.sentry_logger/config.json).
+        dsn:     Backend base URL.  If omitted, uses the production endpoint
+                 (https://api.sentrylabs.live) or the value saved by the CLI.
+                 Can also be overridden with the SENTRY_INGEST_URL env var.
+        batch_size: Logs to buffer before flushing (default 50).
+        flush_interval_seconds: Seconds between automatic flushes (default 5).
+
+    Returns:
+        SentryLogHandler — attach to specific loggers if needed.
+
+    Example (CLI-linked app, zero config):
+        >>> from sentry_logger import init
+        >>> init()
+
+    Example (explicit key):
+        >>> from sentry_logger import init
+        >>> init(api_key="sk_...")
+    """
+    import logging
+
+    resolved_dsn = resolve_dsn(dsn)
+
+    if not api_key:
+        cfg = load_local_config()
+        api_key = cfg.get("api_key")
+        # Also prefer the DSN saved by the CLI if not provided explicitly
+        if not dsn and cfg.get("dsn"):
+            resolved_dsn = str(cfg["dsn"]).rstrip("/")
+
+    if not api_key:
+        raise ValueError(
+            "api_key is required. Either run `sentry-logger init` first, "
+            "or pass api_key= to init()."
+        )
+
+    config = SentryLoggerConfig(
+        api_key=api_key,
+        batch_size=batch_size,
+        flush_interval_seconds=flush_interval_seconds,
+        _backend_url=resolved_dsn,
+    )
+    handler = SentryLogHandler(config)
+    logging.getLogger().addHandler(handler)
+    logging.getLogger().setLevel(logging.INFO)
+    return handler

sentry_logger-0.1.0/sentry_logger/cli.py

@@ -0,0 +1,150 @@
+"""CLI for one-command SDK onboarding."""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import time
+from typing import Optional
+import urllib.error
+import urllib.parse
+import urllib.request
+import webbrowser
+
+from .local_config import DEFAULT_DSN, get_default_config_path, load_local_config, save_local_config
+
+
+def _http_json(method: str, url: str, payload: Optional[dict] = None) -> dict:
+    data = json.dumps(payload).encode("utf-8") if payload is not None else None
+    request = urllib.request.Request(
+        url,
+        method=method,
+        data=data,
+        headers={"Content-Type": "application/json"},
+    )
+    with urllib.request.urlopen(request, timeout=15) as response:
+        body = response.read().decode("utf-8")
+        return json.loads(body) if body else {}
+
+
+def cmd_init(args: argparse.Namespace) -> int:
+    dsn = args.dsn.rstrip("/")
+    try:
+        start = _http_json(
+            "POST",
+            f"{dsn}/sdk/device/start",
+            {
+                "app_name": args.app_name,
+                "description": args.description,
+                "ttl_seconds": args.ttl_seconds,
+            },
+        )
+    except urllib.error.HTTPError as exc:
+        print(f"Failed to start login flow: HTTP {exc.code}", file=sys.stderr)
+        return 1
+    except Exception as exc:
+        print(f"Failed to start login flow: {type(exc).__name__}", file=sys.stderr)
+        return 1
+
+    verification_uri_complete = start["verification_uri_complete"]
+    user_code = start["user_code"]
+    device_code = start["device_code"]
+    interval = int(start.get("interval", 3))
+
+    print("Open this URL to login and link your app:")
+    print(verification_uri_complete)
+    print(f"If prompted, enter code: {user_code}")
+
+    if not args.no_browser:
+        webbrowser.open(verification_uri_complete)
+
+    started = time.monotonic()
+    while True:
+        if (time.monotonic() - started) > args.timeout_seconds:
+            print("Timed out waiting for approval.", file=sys.stderr)
+            return 2
+
+        try:
+            poll_url = f"{dsn}/sdk/device/poll?{urllib.parse.urlencode({'device_code': device_code})}"
+            poll = _http_json("GET", poll_url)
+        except urllib.error.HTTPError as exc:
+            if exc.code == 400:
+                print("Device code expired. Run init again.", file=sys.stderr)
+                return 2
+            time.sleep(interval)
+            continue
+        except Exception:
+            time.sleep(interval)
+            continue
+
+        if poll.get("status") == "approved":
+            payload = {
+                "app_id": poll["app_id"],
+                "app_name": poll.get("app_name", args.app_name),
+                "api_key": poll["api_key"],
+                "dsn": poll.get("dsn", dsn),
+            }
+            saved = save_local_config(payload, path=args.config_path)
+            print("")
+            print(f"Linked app '{payload['app_name']}' ({payload['app_id']}).")
+            print(f"Credentials saved to {saved}.")
+            print("Use in code:")
+            print("  from sentry_logger import init")
+            print("  init()  # reads local config")
+            return 0
+
+        time.sleep(interval)
+
+
+def cmd_status(args: argparse.Namespace) -> int:
+    cfg = load_local_config(path=args.config_path)
+    if not cfg:
+        print(f"No config found at {args.config_path or get_default_config_path()}")
+        return 1
+    print(f"App: {cfg.get('app_name')}")
+    print(f"App ID: {cfg.get('app_id')}")
+    print(f"DSN: {cfg.get('dsn')}")
+    print(f"API key present: {'yes' if cfg.get('api_key') else 'no'}")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="sentry-logger", description="Sentry Logger SDK CLI")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    _dsn_help = f"Backend base URL (default: {DEFAULT_DSN})"
+
+    init_parser = sub.add_parser("init", help="Login in browser and provision app credentials")
+    init_parser.add_argument("--app-name", required=True, help="Name for the app to register")
+    init_parser.add_argument("--description", default="", help="Optional app description")
+    init_parser.add_argument("--dsn", default=DEFAULT_DSN, help=_dsn_help)
+    init_parser.add_argument("--ttl-seconds", type=int, default=600, help="Login session TTL")
+    init_parser.add_argument("--timeout-seconds", type=int, default=300, help="Polling timeout")
+    init_parser.add_argument("--no-browser", action="store_true", help="Do not auto-open browser")
+    init_parser.add_argument("--config-path", default=None, help="Override config file path")
+    init_parser.set_defaults(func=cmd_init)
+
+    login_parser = sub.add_parser("login", help="Alias for init")
+    login_parser.add_argument("--app-name", required=True, help="Name for the app to register")
+    login_parser.add_argument("--description", default="", help="Optional app description")
+    login_parser.add_argument("--dsn", default=DEFAULT_DSN, help=_dsn_help)
+    login_parser.add_argument("--ttl-seconds", type=int, default=600, help="Login session TTL")
+    login_parser.add_argument("--timeout-seconds", type=int, default=300, help="Polling timeout")
+    login_parser.add_argument("--no-browser", action="store_true", help="Do not auto-open browser")
+    login_parser.add_argument("--config-path", default=None, help="Override config file path")
+    login_parser.set_defaults(func=cmd_init)
+
+    status_parser = sub.add_parser("status", help="Show current local SDK config")
+    status_parser.add_argument("--config-path", default=None, help="Override config file path")
+    status_parser.set_defaults(func=cmd_status)
+    return parser
+
+
+def main() -> int:
+    parser = build_parser()
+    args = parser.parse_args()
+    return int(args.func(args))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

sentry_logger-0.1.0/sentry_logger/config.py

@@ -0,0 +1,25 @@
+"""Configuration for Sentry Logger SDK."""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class SentryLoggerConfig:
+    api_key: str
+    batch_size: int = 50
+    flush_interval_seconds: float = 5.0
+
+    # Internal - URL is set via environment variable or resolved from local config
+    _backend_url: Optional[str] = field(default=None, repr=False)
+
+    def __post_init__(self):
+        if not self._backend_url:
+            self._backend_url = os.environ.get(
+                "SENTRY_INGEST_URL",
+                "https://api.sentrylabs.live",
+            )
+        self._backend_url = self._backend_url.rstrip("/")
+        self.ingest_url = f"{self._backend_url}/ingest"

sentry_logger-0.1.0/sentry_logger/handler.py

@@ -0,0 +1,73 @@
+"""
+Logging handler that buffers log records and sends them in batches to the Sentry ingest API.
+"""
+import atexit
+import json
+import logging
+import threading
+import time
+import urllib.request
+
+from .config import SentryLoggerConfig
+
+
+class SentryLogHandler(logging.Handler):
+    """
+    Buffers log records and POSTs them in batches to the Sentry ingest endpoint.
+    Uses a background thread for non-blocking sends.
+    """
+
+    def __init__(self, config: SentryLoggerConfig):
+        super().__init__()
+        self.config = config
+        self._buffer: list[str] = []
+        self._lock = threading.Lock()
+        self._shutdown = False
+        self._last_flush = time.monotonic()
+        self.setFormatter(
+            logging.Formatter("%(asctime)s [%(levelname)s] [%(name)s]: %(message)s")
+        )
+        atexit.register(self.flush)
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            msg = self.format(record)
+            with self._lock:
+                self._buffer.append(msg)
+                now = time.monotonic()
+                if (
+                    len(self._buffer) >= self.config.batch_size
+                    or (now - self._last_flush) >= self.config.flush_interval_seconds
+                ):
+                    self._flush_locked()
+        except Exception:
+            self.handleError(record)
+
+    def _flush_locked(self) -> None:
+        if not self._buffer:
+            return
+        logs = self._buffer[:]
+        self._buffer = []
+        self._last_flush = time.monotonic()
+        threading.Thread(target=self._send, args=(logs,), daemon=True).start()
+
+    def _send(self, logs: list[str]) -> None:
+        try:
+            body = json.dumps({"logs": logs}).encode("utf-8")
+            req = urllib.request.Request(
+                self.config.ingest_url,
+                data=body,
+                method="POST",
+                headers={
+                    "Content-Type": "application/json",
+                    "Authorization": f"Bearer {self.config.api_key}",
+                    "X-API-Key": self.config.api_key,
+                },
+            )
+            urllib.request.urlopen(req, timeout=10)
+        except Exception:
+            pass  # Fail silently to avoid disrupting the app
+
+    def flush(self) -> None:
+        with self._lock:
+            self._flush_locked()

sentry_logger-0.1.0/sentry_logger/local_config.py

@@ -0,0 +1,51 @@
+"""Local CLI config persistence for SDK credentials."""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Optional
+
+
+def get_default_config_path() -> Path:
+    home = Path.home()
+    return home / ".sentry_logger" / "config.json"
+
+
+def ensure_parent(path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+
+def load_local_config(path: Optional[str] = None) -> dict[str, Any]:
+    config_path = Path(path) if path else get_default_config_path()
+    if not config_path.exists():
+        return {}
+    try:
+        with config_path.open("r", encoding="utf-8") as f:
+            payload = json.load(f)
+        return payload if isinstance(payload, dict) else {}
+    except Exception:
+        return {}
+
+
+def save_local_config(payload: dict[str, Any], path: Optional[str] = None) -> Path:
+    config_path = Path(path) if path else get_default_config_path()
+    ensure_parent(config_path)
+    with config_path.open("w", encoding="utf-8") as f:
+        json.dump(payload, f, indent=2)
+    return config_path
+
+
+DEFAULT_DSN = "https://api.sentrylabs.live"
+
+
+def resolve_dsn(explicit_dsn: Optional[str] = None) -> str:
+    if explicit_dsn:
+        return explicit_dsn.rstrip("/")
+    env_dsn = os.environ.get("SENTRY_INGEST_URL")
+    if env_dsn:
+        return env_dsn.rstrip("/")
+    cfg = load_local_config()
+    if cfg.get("dsn"):
+        return str(cfg["dsn"]).rstrip("/")
+    return DEFAULT_DSN

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

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: sentry-logger
+Version: 0.1.0
+Summary: Push logs from your Python app to the Sentry dashboard — AI-powered service health monitoring
+Author-email: Sentry <support@sentrylabs.live>
+License-Expression: MIT
+Project-URL: Homepage, https://sentrylabs.live
+Project-URL: Repository, https://github.com/moiz-frost/sentry
+Project-URL: Bug Tracker, https://github.com/moiz-frost/sentry/issues
+Keywords: logging,monitoring,observability,sentry,dashboard,devtools
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Logging
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Sentry Logger SDK (Python)
+
+Push logs from your Python app to the Sentry dashboard.
+
+## Installation
+
+```bash
+pip install sentry-logger
+# or from the repo:
+pip install ./sdk/python
+```
+
+## Quick Start — CLI + Browser OAuth
+
+```bash
+sentry-logger init --app-name "my-service" --dsn "http://localhost:9000"
+```
+
+What happens:
+
+1. CLI requests a device session from the backend
+2. Browser opens your sign-in page
+3. Sign in with Google — your app is registered and an API key is created
+4. CLI polls and stores credentials in `~/.sentry_logger/config.json`
+
+Check the currently linked app:
+
+```bash
+sentry-logger status
+```
+
+## SDK Usage
+
+```python
+from sentry_logger import init
+
+# Reads api_key and dsn from ~/.sentry_logger/config.json
+init()
+
+import logging
+logging.info("Hello from my app")
+logging.error("Something went wrong")
+```
+
+Explicit configuration:
+
+```python
+from sentry_logger import init
+
+init(
+    api_key="sk_...",
+    dsn="http://localhost:9000",   # your backend URL
+)
+```
+
+## Environment Variables
+
+| Variable           | Default                  | Description                     |
+|--------------------|--------------------------|--------------------------------|
+| `LOGSENTRY_URL`    | `http://localhost:9000`  | Backend ingest URL base        |
+
+## FastAPI Example
+
+```python
+import logging
+from fastapi import FastAPI
+from sentry_logger import init
+
+app = FastAPI()
+
+@app.on_event("startup")
+def setup_logging() -> None:
+    init()
+    logging.getLogger(__name__).info("Sentry SDK initialized")
+```
+
+## Configuration Reference
+
+| Parameter                | Default | Description                                           |
+|--------------------------|---------|-------------------------------------------------------|
+| `api_key`                | —       | API key (`sk_...`). If omitted, loaded from CLI config |
+| `dsn`                    | —       | Ingest URL. Falls back to `LOGSENTRY_URL` env or `http://localhost:8001` |
+| `batch_size`             | `50`    | Send logs when buffer reaches this size               |
+| `flush_interval_seconds` | `5.0`   | Auto-flush buffer after this many seconds             |
+
+## Log Format
+
+The SDK formats logs in the standard Python logging format. The backend parses:
+
+```
+2024-01-01 10:00:00,123 [INFO] [ServiceName]: Log message here
+```
+
+The `ServiceName` in brackets is used to group logs by service in the dashboard.
+Use Python logger names to map to service names:
+
+```python
+logger = logging.getLogger("PaymentService")
+logger.info("Payment processed")
+```

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

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+sentry_logger/__init__.py
+sentry_logger/cli.py
+sentry_logger/config.py
+sentry_logger/handler.py
+sentry_logger/local_config.py
+sentry_logger.egg-info/PKG-INFO
+sentry_logger.egg-info/SOURCES.txt
+sentry_logger.egg-info/dependency_links.txt
+sentry_logger.egg-info/entry_points.txt
+sentry_logger.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

sentry_logger-0.1.0/sentry_logger.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sentry-logger = sentry_logger.cli:main

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

@@ -0,0 +1 @@
+sentry_logger

sentry_logger-0.1.0/setup.cfg

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