nr-log-handler 0.1.0__tar.gz

nr_log_handler-0.1.0/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: nr-log-handler
+Version: 0.1.0
+Summary: Send logs to New Relic via their Log REST API
+Author-email: Your Name <you@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/yourname/newrelic-logger
+Project-URL: Repository, https://github.com/yourname/newrelic-logger
+Keywords: newrelic,logging,observability
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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: Topic :: System :: Logging
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: pytest-mock>=3.11; extra == "dev"
+
+# nr-log-handler
+
+A lightweight Python library for sending logs to [New Relic](https://newrelic.com) via their [Log API](https://docs.newrelic.com/docs/logs/log-api/introduction-log-api/). No New Relic agent required — pure REST API.
+
+## Features
+
+- Works with Python's built-in `logging` module as a drop-in `logging.Handler`
+- Standalone `NewRelicLogger` with `.info()`, `.error()` etc.
+- US and EU region support
+- Sync (immediate) and async (batched, background thread) modes
+- Configurable batch size and flush interval
+- Exponential backoff retry — never crashes your application
+- Global and per-call custom attributes
+
+## Requirements
+
+- Python 3.10+
+- `requests`
+
+## Installation
+
+```bash
+pip install nr-log-handler
+```
+
+## Quick Start
+
+### Standalone logger
+
+```python
+from newrelic_logger import NewRelicLogger
+
+logger = NewRelicLogger(
+    api_key="YOUR_NEW_RELIC_LICENSE_KEY",
+    region="us",               # "us" (default) or "eu"
+    mode="async",              # "sync" (default) or "async"
+    attributes={"service": "my-app", "environment": "production"},
+)
+
+logger.info("Application started")
+logger.error("Something went wrong", extra_attributes={"request_id": "abc-123"})
+
+# Always call close() on shutdown to flush buffered logs
+logger.close()
+```
+
+### As a `logging.Handler`
+
+```python
+import logging
+from newrelic_logger import NewRelicHandler
+
+handler = NewRelicHandler(
+    api_key="YOUR_NEW_RELIC_LICENSE_KEY",
+    region="us",
+    mode="sync",
+    attributes={"service": "my-app"},
+)
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("myapp")
+logger.addHandler(handler)
+
+logger.info("Hello from standard logging")
+```
+
+## Configuration
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `api_key` | `str` | **required** | New Relic license key |
+| `region` | `str` | `"us"` | `"us"` or `"eu"` |
+| `mode` | `str` | `"sync"` | `"sync"` or `"async"` |
+| `batch_size` | `int` | `100` | Max logs per batch (async only) |
+| `flush_interval` | `float` | `5.0` | Seconds between flushes (async only) |
+| `timeout` | `int` | `10` | HTTP timeout in seconds |
+| `max_retries` | `int` | `5` | Max retry attempts on transient failure |
+| `backoff_factor` | `float` | `0.5` | Exponential backoff multiplier |
+| `attributes` | `dict` | `None` | Global attributes on every log entry |
+
+## Error Handling
+
+The library **never raises exceptions** from logging calls. On failure it retries up to `max_retries` times with exponential backoff, then emits a warning via Python's stdlib `logging` to the `newrelic_logger` logger and silently drops the batch.
+
+To capture these internal warnings:
+
+```python
+import logging
+logging.getLogger("newrelic_logger").setLevel(logging.WARNING)
+```
+
+## License
+
+MIT

nr_log_handler-0.1.0/README.md

@@ -0,0 +1,94 @@
+# nr-log-handler
+
+A lightweight Python library for sending logs to [New Relic](https://newrelic.com) via their [Log API](https://docs.newrelic.com/docs/logs/log-api/introduction-log-api/). No New Relic agent required — pure REST API.
+
+## Features
+
+- Works with Python's built-in `logging` module as a drop-in `logging.Handler`
+- Standalone `NewRelicLogger` with `.info()`, `.error()` etc.
+- US and EU region support
+- Sync (immediate) and async (batched, background thread) modes
+- Configurable batch size and flush interval
+- Exponential backoff retry — never crashes your application
+- Global and per-call custom attributes
+
+## Requirements
+
+- Python 3.10+
+- `requests`
+
+## Installation
+
+```bash
+pip install nr-log-handler
+```
+
+## Quick Start
+
+### Standalone logger
+
+```python
+from newrelic_logger import NewRelicLogger
+
+logger = NewRelicLogger(
+    api_key="YOUR_NEW_RELIC_LICENSE_KEY",
+    region="us",               # "us" (default) or "eu"
+    mode="async",              # "sync" (default) or "async"
+    attributes={"service": "my-app", "environment": "production"},
+)
+
+logger.info("Application started")
+logger.error("Something went wrong", extra_attributes={"request_id": "abc-123"})
+
+# Always call close() on shutdown to flush buffered logs
+logger.close()
+```
+
+### As a `logging.Handler`
+
+```python
+import logging
+from newrelic_logger import NewRelicHandler
+
+handler = NewRelicHandler(
+    api_key="YOUR_NEW_RELIC_LICENSE_KEY",
+    region="us",
+    mode="sync",
+    attributes={"service": "my-app"},
+)
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("myapp")
+logger.addHandler(handler)
+
+logger.info("Hello from standard logging")
+```
+
+## Configuration
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `api_key` | `str` | **required** | New Relic license key |
+| `region` | `str` | `"us"` | `"us"` or `"eu"` |
+| `mode` | `str` | `"sync"` | `"sync"` or `"async"` |
+| `batch_size` | `int` | `100` | Max logs per batch (async only) |
+| `flush_interval` | `float` | `5.0` | Seconds between flushes (async only) |
+| `timeout` | `int` | `10` | HTTP timeout in seconds |
+| `max_retries` | `int` | `5` | Max retry attempts on transient failure |
+| `backoff_factor` | `float` | `0.5` | Exponential backoff multiplier |
+| `attributes` | `dict` | `None` | Global attributes on every log entry |
+
+## Error Handling
+
+The library **never raises exceptions** from logging calls. On failure it retries up to `max_retries` times with exponential backoff, then emits a warning via Python's stdlib `logging` to the `newrelic_logger` logger and silently drops the batch.
+
+To capture these internal warnings:
+
+```python
+import logging
+logging.getLogger("newrelic_logger").setLevel(logging.WARNING)
+```
+
+## License
+
+MIT

nr_log_handler-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nr-log-handler"
+version = "0.1.0"
+description = "Send logs to New Relic via their Log REST API"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "Your Name", email = "you@example.com" }]
+requires-python = ">=3.10"
+dependencies = ["requests>=2.28"]
+keywords = ["newrelic", "logging", "observability"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: System :: Logging",
+]
+
+[project.urls]
+Homepage = "https://github.com/yourname/newrelic-logger"
+Repository = "https://github.com/yourname/newrelic-logger"
+
+[project.optional-dependencies]
+dev = ["pytest>=7.4", "pytest-mock>=3.11"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

nr_log_handler-0.1.0/setup.cfg

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

nr_log_handler-0.1.0/src/newrelic_logger/__init__.py

@@ -0,0 +1,12 @@
+from newrelic_logger.handler import NewRelicHandler
+from newrelic_logger.logger import NewRelicLogger
+from newrelic_logger.exceptions import NewRelicLoggerError, ConfigurationError
+
+__all__ = [
+    "NewRelicHandler",
+    "NewRelicLogger",
+    "NewRelicLoggerError",
+    "ConfigurationError",
+]
+
+__version__ = "0.1.0"

nr_log_handler-0.1.0/src/newrelic_logger/batch.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import queue
+import threading
+import time
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from newrelic_logger.client import NewRelicClient
+
+
+class BatchQueue:
+    def __init__(
+        self,
+        client: NewRelicClient,
+        batch_size: int = 100,
+        flush_interval: float = 5.0,
+        common_attributes: dict | None = None,
+    ) -> None:
+        self._client = client
+        self._batch_size = batch_size
+        self._flush_interval = flush_interval
+        self._common_attributes = common_attributes
+        self._queue: queue.Queue[dict] = queue.Queue()
+        self._lock = threading.Lock()
+        self._stop_event = threading.Event()
+        self._thread = threading.Thread(target=self._run, daemon=True)
+        self._thread.start()
+
+    def put(self, log: dict) -> None:
+        self._queue.put(log)
+        if self._queue.qsize() >= self._batch_size:
+            self._flush()
+
+    def _run(self) -> None:
+        last_flush = time.monotonic()
+        while not self._stop_event.is_set():
+            elapsed = time.monotonic() - last_flush
+            if elapsed >= self._flush_interval:
+                self._flush()
+                last_flush = time.monotonic()
+            time.sleep(0.05)
+
+    def _flush(self) -> None:
+        with self._lock:
+            batch: list[dict] = []
+            try:
+                while True:
+                    batch.append(self._queue.get_nowait())
+            except queue.Empty:
+                pass
+            if batch:
+                self._client.send(batch, common_attributes=self._common_attributes)
+
+    def flush(self) -> None:
+        self._flush()
+
+    def close(self) -> None:
+        self._stop_event.set()
+        self._thread.join(timeout=5.0)
+        self._flush()

nr_log_handler-0.1.0/src/newrelic_logger/client.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import json
+import logging
+import time
+
+import requests
+
+from newrelic_logger.exceptions import ConfigurationError
+
+_ENDPOINTS: dict[str, str] = {
+    "us": "https://log-api.newrelic.com/log/v1",
+    "eu": "https://log-api.eu.newrelic.com/log/v1",
+}
+
+_internal_logger = logging.getLogger("newrelic_logger")
+
+
+class NewRelicClient:
+    def __init__(
+        self,
+        api_key: str,
+        region: str = "us",
+        timeout: int = 10,
+        max_retries: int = 5,
+        backoff_factor: float = 0.5,
+    ) -> None:
+        if not api_key:
+            raise ConfigurationError("api_key is required and must not be empty.")
+        if region not in _ENDPOINTS:
+            raise ConfigurationError(f"Invalid region '{region}'. Must be one of: {set(_ENDPOINTS)}")
+        self._api_key = api_key
+        self._endpoint = _ENDPOINTS[region]
+        self._timeout = timeout
+        self._max_retries = max_retries
+        self._backoff_factor = backoff_factor
+
+    def send(self, logs: list[dict], common_attributes: dict | None = None) -> None:
+        entry: dict = {"logs": logs}
+        if common_attributes:
+            entry["common"] = {"attributes": common_attributes}
+        payload = json.dumps([entry])
+        headers = {
+            "Api-Key": self._api_key,
+            "Content-Type": "application/json",
+        }
+        self._post_with_retry(payload, headers, logs)
+
+    def _post_with_retry(self, payload: str, headers: dict, logs: list[dict]) -> None:
+        last_exc: Exception | None = None
+        for attempt in range(self._max_retries + 1):
+            if attempt > 0:
+                wait = self._backoff_factor * (2 ** (attempt - 1))
+                time.sleep(wait)
+            try:
+                response = requests.post(
+                    self._endpoint, data=payload, headers=headers, timeout=self._timeout
+                )
+                if response.ok:
+                    return
+                if response.status_code in (400, 403):
+                    _internal_logger.warning(
+                        "newrelic_logger: Permanent failure sending %d log(s) — HTTP %d: %s",
+                        len(logs),
+                        response.status_code,
+                        response.text,
+                    )
+                    return
+                last_exc = RuntimeError(f"HTTP {response.status_code}: {response.text}")
+            except requests.RequestException as exc:
+                last_exc = exc
+
+        _internal_logger.warning(
+            "newrelic_logger: Failed to send %d log(s) to New Relic after %d retries: %s",
+            len(logs),
+            self._max_retries,
+            str(last_exc),
+        )

nr_log_handler-0.1.0/src/newrelic_logger/exceptions.py

@@ -0,0 +1,6 @@
+class NewRelicLoggerError(Exception):
+    """Base exception for newrelic-logger."""
+
+
+class ConfigurationError(NewRelicLoggerError):
+    """Raised when the handler/logger is misconfigured at init time."""

nr_log_handler-0.1.0/src/newrelic_logger/handler.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import logging
+
+from newrelic_logger.client import NewRelicClient
+from newrelic_logger.batch import BatchQueue
+from newrelic_logger.exceptions import ConfigurationError
+
+_VALID_REGIONS = {"us", "eu"}
+_VALID_MODES = {"sync", "async"}
+
+
+class NewRelicHandler(logging.Handler):
+    def __init__(
+        self,
+        api_key: str = "",
+        region: str = "us",
+        mode: str = "sync",
+        batch_size: int = 100,
+        flush_interval: float = 5.0,
+        timeout: int = 10,
+        max_retries: int = 5,
+        backoff_factor: float = 0.5,
+        attributes: dict | None = None,
+        level: int = logging.NOTSET,
+    ) -> None:
+        if not api_key:
+            raise ConfigurationError("api_key is required and must not be empty.")
+        if region not in _VALID_REGIONS:
+            raise ConfigurationError(f"Invalid region '{region}'. Must be one of: {_VALID_REGIONS}")
+        if mode not in _VALID_MODES:
+            raise ConfigurationError(f"Invalid mode '{mode}'. Must be one of: {_VALID_MODES}")
+
+        super().__init__(level)
+        self._global_attributes: dict = attributes or {}
+        self._mode = mode
+        self._client = NewRelicClient(
+            api_key=api_key,
+            region=region,
+            timeout=timeout,
+            max_retries=max_retries,
+            backoff_factor=backoff_factor,
+        )
+        self._batch_queue: BatchQueue | None = None
+        if mode == "async":
+            self._batch_queue = BatchQueue(
+                client=self._client,
+                batch_size=batch_size,
+                flush_interval=flush_interval,
+                common_attributes=self._global_attributes or None,
+            )
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            extra_attrs: dict = getattr(record, "extra_attributes", {}) or {}
+            log_dict = {
+                "timestamp": int(record.created * 1000),
+                "message": self.format(record) if self.formatter else record.getMessage(),
+                "level": record.levelname,
+                "attributes": extra_attrs,
+            }
+            if self._mode == "async" and self._batch_queue is not None:
+                self._batch_queue.put(log_dict)
+            else:
+                self._client.send([log_dict], common_attributes=self._global_attributes or None)
+        except Exception:
+            self.handleError(record)
+
+    def close(self) -> None:
+        if self._batch_queue is not None:
+            self._batch_queue.close()
+        super().close()

nr_log_handler-0.1.0/src/newrelic_logger/logger.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import logging
+import uuid
+
+from newrelic_logger.handler import NewRelicHandler
+
+
+class NewRelicLogger:
+    def __init__(
+        self,
+        api_key: str = "",
+        region: str = "us",
+        mode: str = "sync",
+        batch_size: int = 100,
+        flush_interval: float = 5.0,
+        timeout: int = 10,
+        max_retries: int = 5,
+        backoff_factor: float = 0.5,
+        attributes: dict | None = None,
+    ) -> None:
+        self._handler = NewRelicHandler(
+            api_key=api_key,
+            region=region,
+            mode=mode,
+            batch_size=batch_size,
+            flush_interval=flush_interval,
+            timeout=timeout,
+            max_retries=max_retries,
+            backoff_factor=backoff_factor,
+            attributes=attributes,
+        )
+        # Use a unique logger name to avoid collisions between instances
+        self._logger = logging.getLogger(f"newrelic_logger.user.{uuid.uuid4().hex}")
+        self._logger.addHandler(self._handler)
+        self._logger.setLevel(logging.DEBUG)
+        self._logger.propagate = False
+
+    def _log(self, level: int, msg: str, extra_attributes: dict | None = None) -> None:
+        extra = {"extra_attributes": extra_attributes or {}}
+        self._logger.log(level, msg, extra=extra)
+
+    def debug(self, msg: str, extra_attributes: dict | None = None) -> None:
+        self._log(logging.DEBUG, msg, extra_attributes)
+
+    def info(self, msg: str, extra_attributes: dict | None = None) -> None:
+        self._log(logging.INFO, msg, extra_attributes)
+
+    def warning(self, msg: str, extra_attributes: dict | None = None) -> None:
+        self._log(logging.WARNING, msg, extra_attributes)
+
+    def error(self, msg: str, extra_attributes: dict | None = None) -> None:
+        self._log(logging.ERROR, msg, extra_attributes)
+
+    def critical(self, msg: str, extra_attributes: dict | None = None) -> None:
+        self._log(logging.CRITICAL, msg, extra_attributes)
+
+    def close(self) -> None:
+        self._handler.close()
+        self._logger.removeHandler(self._handler)

nr_log_handler-0.1.0/src/nr_log_handler.egg-info/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: nr-log-handler
+Version: 0.1.0
+Summary: Send logs to New Relic via their Log REST API
+Author-email: Your Name <you@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/yourname/newrelic-logger
+Project-URL: Repository, https://github.com/yourname/newrelic-logger
+Keywords: newrelic,logging,observability
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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: Topic :: System :: Logging
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: pytest-mock>=3.11; extra == "dev"
+
+# nr-log-handler
+
+A lightweight Python library for sending logs to [New Relic](https://newrelic.com) via their [Log API](https://docs.newrelic.com/docs/logs/log-api/introduction-log-api/). No New Relic agent required — pure REST API.
+
+## Features
+
+- Works with Python's built-in `logging` module as a drop-in `logging.Handler`
+- Standalone `NewRelicLogger` with `.info()`, `.error()` etc.
+- US and EU region support
+- Sync (immediate) and async (batched, background thread) modes
+- Configurable batch size and flush interval
+- Exponential backoff retry — never crashes your application
+- Global and per-call custom attributes
+
+## Requirements
+
+- Python 3.10+
+- `requests`
+
+## Installation
+
+```bash
+pip install nr-log-handler
+```
+
+## Quick Start
+
+### Standalone logger
+
+```python
+from newrelic_logger import NewRelicLogger
+
+logger = NewRelicLogger(
+    api_key="YOUR_NEW_RELIC_LICENSE_KEY",
+    region="us",               # "us" (default) or "eu"
+    mode="async",              # "sync" (default) or "async"
+    attributes={"service": "my-app", "environment": "production"},
+)
+
+logger.info("Application started")
+logger.error("Something went wrong", extra_attributes={"request_id": "abc-123"})
+
+# Always call close() on shutdown to flush buffered logs
+logger.close()
+```
+
+### As a `logging.Handler`
+
+```python
+import logging
+from newrelic_logger import NewRelicHandler
+
+handler = NewRelicHandler(
+    api_key="YOUR_NEW_RELIC_LICENSE_KEY",
+    region="us",
+    mode="sync",
+    attributes={"service": "my-app"},
+)
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("myapp")
+logger.addHandler(handler)
+
+logger.info("Hello from standard logging")
+```
+
+## Configuration
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `api_key` | `str` | **required** | New Relic license key |
+| `region` | `str` | `"us"` | `"us"` or `"eu"` |
+| `mode` | `str` | `"sync"` | `"sync"` or `"async"` |
+| `batch_size` | `int` | `100` | Max logs per batch (async only) |
+| `flush_interval` | `float` | `5.0` | Seconds between flushes (async only) |
+| `timeout` | `int` | `10` | HTTP timeout in seconds |
+| `max_retries` | `int` | `5` | Max retry attempts on transient failure |
+| `backoff_factor` | `float` | `0.5` | Exponential backoff multiplier |
+| `attributes` | `dict` | `None` | Global attributes on every log entry |
+
+## Error Handling
+
+The library **never raises exceptions** from logging calls. On failure it retries up to `max_retries` times with exponential backoff, then emits a warning via Python's stdlib `logging` to the `newrelic_logger` logger and silently drops the batch.
+
+To capture these internal warnings:
+
+```python
+import logging
+logging.getLogger("newrelic_logger").setLevel(logging.WARNING)
+```
+
+## License
+
+MIT

nr_log_handler-0.1.0/src/nr_log_handler.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+src/newrelic_logger/__init__.py
+src/newrelic_logger/batch.py
+src/newrelic_logger/client.py
+src/newrelic_logger/exceptions.py
+src/newrelic_logger/handler.py
+src/newrelic_logger/logger.py
+src/nr_log_handler.egg-info/PKG-INFO
+src/nr_log_handler.egg-info/SOURCES.txt
+src/nr_log_handler.egg-info/dependency_links.txt
+src/nr_log_handler.egg-info/requires.txt
+src/nr_log_handler.egg-info/top_level.txt
+tests/test_batch.py
+tests/test_client.py
+tests/test_exceptions.py
+tests/test_handler.py
+tests/test_logger.py

nr_log_handler-0.1.0/src/nr_log_handler.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nr_log_handler-0.1.0/src/nr_log_handler.egg-info/requires.txt

@@ -0,0 +1,5 @@
+requests>=2.28
+
+[dev]
+pytest>=7.4
+pytest-mock>=3.11

nr_log_handler-0.1.0/src/nr_log_handler.egg-info/top_level.txt

@@ -0,0 +1 @@
+newrelic_logger

nr_log_handler-0.1.0/tests/test_batch.py

@@ -0,0 +1,64 @@
+import time
+import threading
+from unittest.mock import MagicMock, patch
+from newrelic_logger.batch import BatchQueue
+
+
+def make_client():
+    client = MagicMock()
+    client.send = MagicMock()
+    return client
+
+
+def test_flush_on_batch_size():
+    client = make_client()
+    q = BatchQueue(client=client, batch_size=3, flush_interval=60.0)
+    try:
+        log = {"timestamp": 1000, "message": "x", "level": "INFO", "attributes": {}}
+        q.put(log)
+        q.put(log)
+        q.put(log)  # triggers flush
+        time.sleep(0.1)
+        client.send.assert_called_once()
+        args = client.send.call_args[0][0]
+        assert len(args) == 3
+    finally:
+        q.close()
+
+
+def test_flush_on_interval():
+    client = make_client()
+    q = BatchQueue(client=client, batch_size=100, flush_interval=0.1)
+    try:
+        log = {"timestamp": 1000, "message": "x", "level": "INFO", "attributes": {}}
+        q.put(log)
+        time.sleep(1.0)  # increased from 0.4 to 1.0 for CI reliability
+        client.send.assert_called_once()
+    finally:
+        q.close()
+
+
+def test_close_flushes_remaining():
+    client = make_client()
+    q = BatchQueue(client=client, batch_size=100, flush_interval=60.0)
+    log = {"timestamp": 1000, "message": "x", "level": "INFO", "attributes": {}}
+    q.put(log)
+    q.put(log)
+    q.close()
+    client.send.assert_called_once()
+    args = client.send.call_args[0][0]
+    assert len(args) == 2
+
+
+def test_thread_safe_concurrent_puts():
+    client = make_client()
+    q = BatchQueue(client=client, batch_size=1000, flush_interval=60.0)
+    log = {"timestamp": 1000, "message": "x", "level": "INFO", "attributes": {}}
+    threads = [threading.Thread(target=q.put, args=(log,)) for _ in range(50)]
+    for t in threads:
+        t.start()
+    for t in threads:
+        t.join()
+    q.close()
+    total_sent = sum(len(call[0][0]) for call in client.send.call_args_list)
+    assert total_sent == 50

nr_log_handler-0.1.0/tests/test_client.py

@@ -0,0 +1,150 @@
+import json
+import pytest
+import requests
+from unittest.mock import patch, MagicMock
+from newrelic_logger.client import NewRelicClient
+from newrelic_logger.exceptions import ConfigurationError
+
+
+@pytest.fixture
+def client():
+    return NewRelicClient(api_key="test-key", region="us")
+
+
+def test_send_posts_to_us_endpoint(client):
+    logs = [{"timestamp": 1000, "message": "hello", "level": "INFO", "attributes": {}}]
+    with patch("newrelic_logger.client.requests.post") as mock_post:
+        mock_post.return_value = MagicMock(status_code=202, ok=True)
+        client.send(logs)
+
+    mock_post.assert_called_once()
+    url = mock_post.call_args.args[0]
+    assert url == "https://log-api.newrelic.com/log/v1"
+
+
+def test_send_posts_to_eu_endpoint():
+    eu_client = NewRelicClient(api_key="test-key", region="eu")
+    logs = [{"timestamp": 1000, "message": "hello", "level": "INFO", "attributes": {}}]
+    with patch("newrelic_logger.client.requests.post") as mock_post:
+        mock_post.return_value = MagicMock(status_code=202, ok=True)
+        eu_client.send(logs)
+
+    url = mock_post.call_args.args[0]
+    assert url == "https://log-api.eu.newrelic.com/log/v1"
+
+
+def test_send_sets_api_key_header(client):
+    logs = [{"timestamp": 1000, "message": "hello", "level": "INFO", "attributes": {}}]
+    with patch("newrelic_logger.client.requests.post") as mock_post:
+        mock_post.return_value = MagicMock(status_code=202, ok=True)
+        client.send(logs)
+
+    headers = mock_post.call_args.kwargs["headers"]
+    assert headers["Api-Key"] == "test-key"
+    assert headers["Content-Type"] == "application/json"
+
+
+def test_send_builds_correct_payload(client):
+    logs = [
+        {"timestamp": 1711000000000, "message": "test msg", "level": "ERROR", "attributes": {"x": "1"}},
+    ]
+    with patch("newrelic_logger.client.requests.post") as mock_post:
+        mock_post.return_value = MagicMock(status_code=202, ok=True)
+        client.send(logs)
+
+    payload = json.loads(mock_post.call_args.kwargs["data"])
+    assert payload[0]["logs"][0]["message"] == "test msg"
+    assert payload[0]["logs"][0]["level"] == "ERROR"
+    assert payload[0]["logs"][0]["timestamp"] == 1711000000000
+    assert payload[0]["logs"][0]["attributes"] == {"x": "1"}
+
+
+def test_send_includes_common_attributes_in_payload(client):
+    logs = [{"timestamp": 1000, "message": "test", "level": "INFO", "attributes": {}}]
+    with patch("newrelic_logger.client.requests.post") as mock_post:
+        mock_post.return_value = MagicMock(status_code=202, ok=True)
+        client.send(logs, common_attributes={"service": "svc", "env": "prod"})
+
+    payload = json.loads(mock_post.call_args.kwargs["data"])
+    assert payload[0]["common"]["attributes"]["service"] == "svc"
+    assert payload[0]["common"]["attributes"]["env"] == "prod"
+    assert payload[0]["logs"][0]["message"] == "test"
+
+
+def test_send_without_common_attributes_omits_common_block(client):
+    logs = [{"timestamp": 1000, "message": "test", "level": "INFO", "attributes": {}}]
+    with patch("newrelic_logger.client.requests.post") as mock_post:
+        mock_post.return_value = MagicMock(status_code=202, ok=True)
+        client.send(logs)
+
+    payload = json.loads(mock_post.call_args.kwargs["data"])
+    assert "common" not in payload[0]
+
+
+def test_raises_on_invalid_region():
+    with pytest.raises(ConfigurationError, match="region"):
+        NewRelicClient(api_key="key", region="ap")
+
+
+def test_raises_on_empty_api_key():
+    with pytest.raises(ConfigurationError, match="api_key"):
+        NewRelicClient(api_key="")
+
+
+def test_retries_on_429(client):
+    logs = [{"timestamp": 1000, "message": "x", "level": "INFO", "attributes": {}}]
+    responses = [MagicMock(status_code=429, ok=False, text="rate limit")] * 5 + [
+        MagicMock(status_code=202, ok=True)
+    ]
+    with patch("newrelic_logger.client.requests.post", side_effect=responses) as mock_post:
+        with patch("newrelic_logger.client.time.sleep"):
+            client.send(logs)
+    assert mock_post.call_count == 6
+
+
+def test_retries_on_500(client):
+    logs = [{"timestamp": 1000, "message": "x", "level": "INFO", "attributes": {}}]
+    responses = [MagicMock(status_code=500, ok=False, text="err")] * 5 + [
+        MagicMock(status_code=202, ok=True)
+    ]
+    with patch("newrelic_logger.client.requests.post", side_effect=responses) as mock_post:
+        with patch("newrelic_logger.client.time.sleep"):
+            client.send(logs)
+    assert mock_post.call_count == 6
+
+
+def test_no_retry_on_400(client):
+    logs = [{"timestamp": 1000, "message": "x", "level": "INFO", "attributes": {}}]
+    with patch("newrelic_logger.client.requests.post") as mock_post:
+        mock_post.return_value = MagicMock(status_code=400, ok=False, text="bad")
+        client.send(logs)
+    assert mock_post.call_count == 1
+
+
+def test_no_retry_on_403(client):
+    logs = [{"timestamp": 1000, "message": "x", "level": "INFO", "attributes": {}}]
+    with patch("newrelic_logger.client.requests.post") as mock_post:
+        mock_post.return_value = MagicMock(status_code=403, ok=False, text="forbidden")
+        client.send(logs)
+    assert mock_post.call_count == 1
+
+
+def test_warns_after_exhausting_retries(client, caplog):
+    import logging as stdlib_logging
+    logs = [{"timestamp": 1000, "message": "x", "level": "INFO", "attributes": {}}]
+    with patch("newrelic_logger.client.requests.post") as mock_post:
+        mock_post.return_value = MagicMock(status_code=500, ok=False, text="err")
+        with patch("newrelic_logger.client.time.sleep"):
+            with caplog.at_level(stdlib_logging.WARNING, logger="newrelic_logger"):
+                client.send(logs)
+    assert "Failed to send" in caplog.text
+    assert mock_post.call_count == 6  # 1 initial + 5 retries
+
+
+def test_retries_on_connection_error(client):
+    logs = [{"timestamp": 1000, "message": "x", "level": "INFO", "attributes": {}}]
+    with patch("newrelic_logger.client.requests.post") as mock_post:
+        mock_post.side_effect = requests.ConnectionError("no connection")
+        with patch("newrelic_logger.client.time.sleep"):
+            client.send(logs)
+    assert mock_post.call_count == 6  # 1 initial + 5 retries

nr_log_handler-0.1.0/tests/test_exceptions.py

@@ -0,0 +1,12 @@
+from newrelic_logger.exceptions import NewRelicLoggerError, ConfigurationError
+
+
+def test_configuration_error_is_newrelic_logger_error():
+    err = ConfigurationError("bad config")
+    assert isinstance(err, NewRelicLoggerError)
+    assert str(err) == "bad config"
+
+
+def test_newrelic_logger_error_is_exception():
+    err = NewRelicLoggerError("base")
+    assert isinstance(err, Exception)

nr_log_handler-0.1.0/tests/test_handler.py

@@ -0,0 +1,86 @@
+import logging
+import pytest
+from unittest.mock import MagicMock, patch
+from newrelic_logger.handler import NewRelicHandler
+from newrelic_logger.exceptions import ConfigurationError
+
+
+def test_raises_if_no_api_key():
+    with pytest.raises(ConfigurationError, match="api_key"):
+        NewRelicHandler(api_key="")
+
+
+def test_raises_on_invalid_region():
+    with pytest.raises(ConfigurationError, match="region"):
+        NewRelicHandler(api_key="key", region="ap")
+
+
+def test_raises_on_invalid_mode():
+    with pytest.raises(ConfigurationError, match="mode"):
+        NewRelicHandler(api_key="key", mode="streaming")
+
+
+def test_sync_mode_calls_client_send():
+    handler = NewRelicHandler(api_key="key", mode="sync")
+    handler._client = MagicMock()
+    record = logging.LogRecord(
+        name="test", level=logging.INFO, pathname="", lineno=0,
+        msg="hello world", args=(), exc_info=None,
+    )
+    handler.emit(record)
+    handler._client.send.assert_called_once()
+    sent = handler._client.send.call_args[0][0]
+    assert sent[0]["message"] == "hello world"
+    assert sent[0]["level"] == "INFO"
+
+
+def test_async_mode_puts_to_batch_queue():
+    handler = NewRelicHandler(api_key="key", mode="async")
+    handler._batch_queue = MagicMock()
+    record = logging.LogRecord(
+        name="test", level=logging.ERROR, pathname="", lineno=0,
+        msg="async log", args=(), exc_info=None,
+    )
+    handler.emit(record)
+    handler._batch_queue.put.assert_called_once()
+    sent = handler._batch_queue.put.call_args[0][0]
+    assert sent["message"] == "async log"
+    assert sent["level"] == "ERROR"
+
+
+def test_global_attributes_merged():
+    handler = NewRelicHandler(api_key="key", mode="sync", attributes={"service": "svc"})
+    handler._client = MagicMock()
+    record = logging.LogRecord(
+        name="test", level=logging.INFO, pathname="", lineno=0,
+        msg="msg", args=(), exc_info=None,
+    )
+    handler.emit(record)
+    # Global attrs now passed as common_attributes keyword arg
+    call_kwargs = handler._client.send.call_args.kwargs
+    assert call_kwargs["common_attributes"]["service"] == "svc"
+
+
+def test_per_call_attributes_override_global():
+    handler = NewRelicHandler(api_key="key", mode="sync", attributes={"env": "prod"})
+    handler._client = MagicMock()
+    record = logging.LogRecord(
+        name="test", level=logging.INFO, pathname="", lineno=0,
+        msg="msg", args=(), exc_info=None,
+    )
+    record.extra_attributes = {"env": "staging", "req_id": "abc"}
+    handler.emit(record)
+    sent = handler._client.send.call_args[0][0]
+    call_kwargs = handler._client.send.call_args.kwargs
+    # per-call attrs in the log entry itself
+    assert sent[0]["attributes"]["env"] == "staging"
+    assert sent[0]["attributes"]["req_id"] == "abc"
+    # global attrs still in common_attributes
+    assert call_kwargs["common_attributes"]["env"] == "prod"
+
+
+def test_close_calls_batch_queue_close():
+    handler = NewRelicHandler(api_key="key", mode="async")
+    handler._batch_queue = MagicMock()
+    handler.close()
+    handler._batch_queue.close.assert_called_once()

nr_log_handler-0.1.0/tests/test_logger.py

@@ -0,0 +1,70 @@
+import logging
+import pytest
+from unittest.mock import MagicMock
+from newrelic_logger.logger import NewRelicLogger
+from newrelic_logger.exceptions import ConfigurationError
+
+
+def make_logger(**kwargs) -> NewRelicLogger:
+    logger = NewRelicLogger(api_key="test-key", **kwargs)
+    logger._handler._client = MagicMock()
+    return logger
+
+
+def test_raises_if_no_api_key():
+    with pytest.raises(ConfigurationError):
+        NewRelicLogger(api_key="")
+
+
+def test_info_sends_info_level():
+    logger = make_logger()
+    logger.info("info message")
+    sent = logger._handler._client.send.call_args[0][0]
+    assert sent[0]["level"] == "INFO"
+    assert sent[0]["message"] == "info message"
+
+
+def test_debug_sends_debug_level():
+    logger = make_logger()
+    logger.debug("debug message")
+    sent = logger._handler._client.send.call_args[0][0]
+    assert sent[0]["level"] == "DEBUG"
+
+
+def test_warning_sends_warning_level():
+    logger = make_logger()
+    logger.warning("warn message")
+    sent = logger._handler._client.send.call_args[0][0]
+    assert sent[0]["level"] == "WARNING"
+
+
+def test_error_sends_error_level():
+    logger = make_logger()
+    logger.error("error message")
+    sent = logger._handler._client.send.call_args[0][0]
+    assert sent[0]["level"] == "ERROR"
+
+
+def test_critical_sends_critical_level():
+    logger = make_logger()
+    logger.critical("critical message")
+    sent = logger._handler._client.send.call_args[0][0]
+    assert sent[0]["level"] == "CRITICAL"
+
+
+def test_extra_attributes_passed_through():
+    logger = make_logger(attributes={"service": "svc"})
+    logger.info("msg", extra_attributes={"req_id": "xyz"})
+    call_kwargs = logger._handler._client.send.call_args.kwargs
+    sent = logger._handler._client.send.call_args[0][0]
+    # global attr in common_attributes
+    assert call_kwargs["common_attributes"]["service"] == "svc"
+    # per-call attr in log entry attributes
+    assert sent[0]["attributes"]["req_id"] == "xyz"
+
+
+def test_close_flushes_handler():
+    logger = make_logger(mode="async")
+    logger._handler._batch_queue = MagicMock()
+    logger.close()
+    logger._handler._batch_queue.close.assert_called_once()