D-SafeLogger 0.2.0__tar.gz

d_safelogger-0.2.0/BENCHMARK.md

@@ -0,0 +1,192 @@
+# Benchmark Analysis
+
+This document is the public benchmark analysis for D-SafeLogger. It is manually edited and is intended to be usable as the basis for README benchmark claims.
+
+Benchmark facts are kept separately from this analysis:
+
+- Per-run artifacts: [`benchmarks/results/`](benchmarks/results/)
+- Selected-session manifest: [`benchmarks/summary/manifest.json`](benchmarks/summary/manifest.json)
+- Generated summary index: [`benchmarks/summary/index.md`](benchmarks/summary/index.md)
+
+## Executive Summary
+
+D-SafeLogger is competitive in single-process logging, especially in async mode and single-thread workloads. In the selected single-process run, D-SafeLogger async was the throughput leader in 8/16 cells and achieved the lowest p50 latency in 12/16 cells. D-SafeLogger async also beat D-SafeLogger sync in both throughput and p50 latency in all 16 comparable cells.
+
+Multiprocess results should be interpreted differently. D-SafeLogger is not the fastest multiprocess backend in this benchmark; stdlib logging leads throughput in all measured multiprocess performance cells. D-SafeLogger's multiprocess value is not raw speed. Its value is Writer-owned sinks, explicit attach/detach, bounded shutdown, and classified delivery-state observability under operational stress.
+
+The resilience profile is the strongest multiprocess evidence. Across 12 D-SafeLogger resilience summary rows, D-SafeLogger produced classified loss/reject/drop fields for 12/12 rows and fully explained 12/12 rows. That is the benchmark-backed claim: D-SafeLogger can explain what happened to records under backpressure, sink rejection, and mixed worker shutdown, instead of leaving delivery state ambiguous.
+
+## Published Summaries
+
+- Single-process comparison: [`benchmarks/summary/single_process.md`](benchmarks/summary/single_process.md)
+- Multiprocess integrity profile: [`benchmarks/summary/multiprocess_integrity.md`](benchmarks/summary/multiprocess_integrity.md)
+- Multiprocess performance profile: [`benchmarks/summary/multiprocess_performance.md`](benchmarks/summary/multiprocess_performance.md)
+- Multiprocess resilience profile: [`benchmarks/summary/multiprocess_resilience.md`](benchmarks/summary/multiprocess_resilience.md)
+
+## Selected Runs
+
+| Category | Selected Session | Purpose |
+|---|---|---|
+| Single-process | `benchmark_20260506_180018` | Throughput and latency comparison across D-SafeLogger, stdlib logging, loguru, and structlog |
+| Multiprocess integrity | `benchmarks_multi_integ_20260506_185947` | Normal-condition delivery completeness and JSON/route integrity |
+| Multiprocess performance | `benchmarks_multi_perf_20260506_190518` | Raw multiprocess throughput and latency comparison |
+| Multiprocess resilience | `benchmarks_multi_resilience_20260506_211129` | Operational failure-mode observability and classified delivery state |
+
+The selected sessions are controlled by [`benchmarks/summary/manifest.json`](benchmarks/summary/manifest.json). Running a new benchmark does not automatically change the public analysis.
+
+Selection rationale:
+
+- The selected sessions were refreshed together after the v23i publication-readiness fixes so the public summaries and analysis use one current benchmark set.
+- A benchmark session should only replace a selected session when it is intentionally promoted in the manifest and this analysis is reviewed for updated claims.
+
+## Single-Process Results
+
+The single-process benchmark covers Python 3.13 and 3.14, GIL enabled and disabled, text and JSON output, single-thread and multi-thread workloads, and sync/async modes where applicable.
+
+Key results from the selected run:
+
+- D-SafeLogger async beat D-SafeLogger sync on throughput in 16/16 comparable cells.
+- D-SafeLogger async beat D-SafeLogger sync on p50 latency in 16/16 comparable cells.
+- Throughput leaders across all 16 cells: D-SafeLogger async 8/16, structlog sync 5/16, stdlib logging async 3/16.
+- Best D-SafeLogger mode beat all non-D-SafeLogger backends on throughput in 8/16 cells.
+- Best D-SafeLogger mode achieved the lowest p50 latency in 12/16 cells.
+
+The strongest D-SafeLogger single-process result is Python 3.14 with GIL enabled:
+
+| Scenario | D-SafeLogger Mode | Throughput | p50 | p90 | p99 |
+|---|---|---:|---:|---:|---:|
+| text | async | 51,554 msg/s | 16.7 us | 19.6 us | 39.6 us |
+| JSON | async | 52,081 msg/s | 16.7 us | 19.2 us | 36.8 us |
+
+Interpretation:
+
+- D-SafeLogger async is the preferred high-throughput single-process mode in this benchmark.
+- D-SafeLogger's strongest area is low-latency single-process logging, especially under Python 3.14/GIL enabled.
+- Multi-thread throughput is not universally led by D-SafeLogger. structlog sync is strong in several multi-thread cells, and stdlib logging async wins some Python 3.14/GIL enabled multi-thread cells.
+- The correct single-process claim is "competitive and often fastest in low-latency async single-process logging," not "always fastest."
+
+## Multiprocess Integrity Results
+
+The integrity profile checks normal-condition delivery completeness and structured output integrity across D-SafeLogger, stdlib logging, and loguru.
+
+Selected result summary:
+
+| Backend | Raw Runs | Failures | Missing | Duplicates | JSON Parse | Route Mismatch |
+|---|---:|---:|---:|---:|---:|---:|
+| D-SafeLogger | 96 | 0 | 0 | 0 | 0 | 0 |
+| stdlib logging | 96 | 0 | 0 | 0 | 0 | 0 |
+| loguru | 96 | 0 | 0 | 0 | 0 | 0 |
+
+Interpretation:
+
+- Under normal benchmark conditions, all three backends delivered the expected records without missing, duplicate, JSON parse, or route mismatch anomalies.
+- This profile is a correctness gate, not D-SafeLogger's differentiating claim.
+- The result supports that D-SafeLogger's Writer-based multiprocess architecture preserves normal delivery integrity, but it should not be used to claim uniqueness.
+
+## Multiprocess Performance Results
+
+The multiprocess performance profile measures raw throughput and latency for process counts and routing patterns. In this profile, stdlib logging wins throughput in all measured cells.
+
+Average throughput by pattern and scenario:
+
+| Pattern | Scenario | D-SafeLogger avg | stdlib avg | loguru avg | Throughput Wins (DS/std/loguru) |
+|---|---:|---:|---:|---:|---:|
+| root_p1 | text | 797 | 1,280 | 995 | 0/4/0 |
+| root_p1 | JSON | 803 | 1,253 | 1,009 | 0/4/0 |
+| root_p4 | text | 653 | 1,110 | 849 | 0/4/0 |
+| root_p4 | JSON | 659 | 1,134 | 874 | 0/4/0 |
+| root_p8 | text | 468 | 852 | 650 | 0/4/0 |
+| root_p8 | JSON | 456 | 802 | 656 | 0/4/0 |
+| module_p4 | text | 644 | 1,120 | 872 | 0/4/0 |
+| module_p4 | JSON | 643 | 1,084 | 878 | 0/4/0 |
+
+Interpretation:
+
+- D-SafeLogger multiprocess mode has measurable fixed costs: record serialization, client-to-writer IPC, route dispatch, Writer-side reconstruction, sink classification, and close-marker drain accounting.
+- Those costs are intentional tradeoffs for central sink ownership and delivery-state observability.
+- The correct multiprocess performance claim is not "fastest." The correct claim is "controlled, observable, Writer-owned multiprocess logging with explicit failure accounting."
+
+## Multiprocess Resilience Results
+
+The resilience profile measures what can be explained during operational stress. This is the most important multiprocess benchmark for D-SafeLogger's design goals.
+
+Selected result summary:
+
+- D-SafeLogger produced classified loss/reject/drop fields for 12/12 summary rows.
+- D-SafeLogger fully explained 12/12 summary rows.
+- stdlib logging and loguru rows are marked `observability_gap` where accepted/dropped/unexplained state cannot be classified by the benchmarked backend contract.
+
+Representative D-SafeLogger rows:
+
+| Scenario | Python/GIL | Attempted | Accepted | Delivered | KnownRejected | KnownDropped | UnexplainedLost | Shutdown |
+|---|---|---:|---:|---:|---:|---:|---:|---|
+| burst_backpressure | 3.13/enabled | 100 | 100 | 99 | 0 | 1 | 0 | clean |
+| burst_backpressure | 3.14/enabled | 100 | 100 | 100 | 0 | 0 | 0 | clean |
+| burst_backpressure | 3.14/disabled | 100 | 100 | 100 | 0 | 0 | 0 | clean |
+| rolling_restart_mixed_shutdown | all measured | 62 | 62 | 62 | 0 | 0 | 0 | clean_with_worker_crash |
+| sink_temporarily_unavailable | all measured | 100 | 100 | 0 | 100 | 0 | 0 | clean |
+
+Interpretation:
+
+- In backpressure scenarios, D-SafeLogger may drop records, but the drops are classified as known drops rather than unexplained loss.
+- In mixed shutdown scenarios, D-SafeLogger can distinguish a clean writer shutdown with worker crash/termination from unexplained record loss.
+- In sink-unavailable scenarios, D-SafeLogger classifies rejected records as known sink rejects rather than reporting ambiguous loss.
+- This is the core multiprocess claim: D-SafeLogger does not promise impossible failure-free logging; it promises explicit accounting of what happened.
+
+## What To Claim
+
+- D-SafeLogger has zero runtime dependencies.
+- D-SafeLogger provides append-only file handling without rename/truncate rotation.
+- D-SafeLogger supports structured JSON logging and stdlib-compatible logger integration.
+- D-SafeLogger async is competitive in single-process logging and leads several low-latency cells in the selected benchmark.
+- D-SafeLogger multiprocess mode centralizes sink ownership in a Writer runtime.
+- D-SafeLogger multiprocess resilience profiling exposes classified delivery-state counters: attempted, accepted, delivered, known rejected, known dropped, and unexplained lost.
+
+## What Not To Claim
+
+- Do not claim D-SafeLogger is always the fastest backend.
+- Do not claim D-SafeLogger multiprocess mode beats stdlib logging on raw throughput in this benchmark.
+- Do not claim multiprocess logging can never lose records under operational failure.
+- Do not claim sink outage, worker crash, or hard process termination is made impossible.
+- Do not mix diagnostic benchmark results with normal logging throughput results.
+
+## Reproduction
+
+Official tests use the dev dependency group. The library runtime remains dependency-free; the test environment does not.
+
+```bash
+uv sync --group dev
+uv run pytest tests -v
+```
+
+Single-process benchmark:
+
+```bash
+uv sync --group benchmark
+uv run python benchmarks/run_benchmark.py
+```
+
+Multiprocess resilience benchmark:
+
+```bash
+uv sync --group benchmark
+uv run python benchmarks/run_multiprocess_compare_v23a.py --repo-root . --profile resilience_profile --messages 100 --repeat 1
+```
+
+Regenerate selected summary files from the manifest:
+
+```bash
+uv run python benchmarks/update_summary.py
+```
+
+## Maintenance Model
+
+Benchmark runners write session artifacts under `benchmarks/results/`. They do not edit this document.
+
+To promote a benchmark run into the public summary:
+
+1. Add or update the session name in `benchmarks/summary/manifest.json`.
+2. Run `uv run python benchmarks/update_summary.py`.
+3. Review the generated files in `benchmarks/summary/`.
+4. Manually update this analysis only when the interpretation or published claim changes.
+5. When promoted benchmark values are cited in `README.md` or `README_ja.md`, update those README claims in the same change.

d_safelogger-0.2.0/CHANGELOG.md

@@ -0,0 +1,68 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.0] - 2026-05-05
+
+### Added
+- Formal multiprocess public API under `dsafelogger.mp`, including `ConfigureLogger`, `AttachCurrentProcess`, `DetachCurrentProcess`, `GetLogger`, `GetWorkerInitializer`, and `ReopenLogFiles`.
+- Writer-runtime multiprocess architecture with separate log plane and control plane, CloseMarker-based drain, explicit attach/detach, and bounded shutdown behavior.
+- Classified multiprocess delivery-state counters for route/reconstruct/close-marker/sink/policy rejects, partial delivery, best-effort failures, timeout drops, overload shed, and drain-deadline loss.
+- `TrackedQueue` for qsize-visible multiprocess log queues with platform fallback.
+- Multiprocess comparison benchmark runner at `benchmarks/run_multiprocess_compare_v23a.py` with integrity, performance, overload, and resilience profiles.
+- Benchmark summary manifest workflow via `benchmarks/summary/manifest.json` and `benchmarks/update_summary.py`.
+- Generated benchmark summary documents under `benchmarks/summary/` while keeping `BENCHMARK.md` manually edited.
+- `optional_integration` pytest marker for OpenTelemetry and structlog coexistence tests while keeping them in the official full test run.
+- v23j public design documents under `docs/design/` reflecting formal MP, dev full-test policy, manifest-based benchmark publication, and strict invalid-configuration handling.
+- Shared v23j configuration validation for single-process, module-specific, and multiprocess file sinks.
+- Generated API documentation under `docs/api/` with `scripts/generate_api_docs.py --check`.
+- Public design-document readiness check via `scripts/check_design_docs_sync.py`.
+- Multiprocess and external-rotation tutorials covering `dsafelogger.mp` and `ReopenLogFiles()`.
+
+### Changed
+- Updated `README.md`, `README_ja.md`, `TESTING.md`, and `BENCHMARK.md` to describe the current v23j design, test policy, benchmark interpretation, and formal multiprocess support.
+- Invalid routing/generation/hash combinations are now fail-fast `ValueError` cases instead of warnings or silent no-ops.
+- `structured=True` is mutually exclusive with `fmt`, `file_fmt`, and `console_fmt` after all config layers are merged.
+- `file_fmt` and `console_fmt` are now accepted by the single-process API and INI/config_dict loader, matching the public design docs.
+- Multiprocess module-specific levels are propagated to attached worker loggers.
+- Multiprocess spawn integration tests now use the same multiprocessing context for Writer IPC primitives and worker process creation.
+- Multiprocess log queue creation now classifies platform-rejected `ipc_log_queue_maxsize` values as `ValueError` before Writer sinks are started, while preserving runtime errors for non-validation OS failures.
+- Tests no longer depend on `multiprocessing.Queue.empty()` for correctness.
+- Benchmark runners now write session artifacts only; they no longer regenerate top-level `BENCHMARK.md`.
+- Official testing policy is now `uv sync --group dev` followed by the full `uv run pytest tests -v` run.
+- Package metadata version and public `dsafelogger.__version__` are both `0.2.0`; project classifier is now Beta.
+- Package license metadata now uses SPDX `license = "Apache-2.0"` and `license-files = ["LICENSE"]`.
+- GitHub CI now checks generated API docs, design-document sync, benchmark summaries, and package build output.
+- PyPI publish workflow now verifies tag/version consistency and repeats publication preflight checks before publishing.
+- GitHub CI now includes Ubuntu free-threaded CPython `3.13t` and `3.14t` test jobs with `PYTHON_GIL=0`.
+
+### Verified
+- Full local v23j validation on Python 3.14.3 / Windows: `651 passed, 3 skipped` (`654` collected). Skip counts can vary by platform because fork tests are POSIX-only and Windows spawn tests are Windows-only.
+- Targeted v23j configuration validation: `256 passed` across configure, routing, INI, reopen, and MP integration tests.
+- Coverage validation regenerated `coverage.xml`: terminal total `86%`, line-rate `88.49%`, branch-rate `80.53%`.
+- Targeted regression validation for MP runtime, MP integration, OpenTelemetry, and structlog tests: `91 passed`.
+- Benchmark summary manifest generation and `--check` verification pass.
+
+## [0.1.0] - 2026-04-03
+
+### Added
+- Initial release
+- 3-layer configuration pipeline (Environment → INI/Dict → Arguments)
+- 9 routing strategies (none, daily, hourly, min_interval, startup_interval, size, count, cyclic_weekday, cyclic_month)
+- Append-only file handler (Windows lock-safe)
+- SHA-256 integrity verification with sidecar files and manifest
+- Structured JSON Lines output
+- Diagnostic formatter with f_locals expansion and sensitive data masking
+- ANSI color console output with customizable palette
+- Async logging mode with context-preserving QueueHandler
+- Custom log level registration with `register_level()`
+- `contextualize()` context manager for structured log context
+- CLI tool (`dsafelogger init/ls/tail -f`)
+- Free-threaded Python (3.13t/3.14t) support with explicit locks
+- Per-module log level and file routing
+- INI file and dict-based configuration
+- Safe shutdown with worker thread join
+- Complete standard library `logging` compatibility

d_safelogger-0.2.0/CONTRIBUTING.md

@@ -0,0 +1,78 @@
+# Contributing to D-SafeLogger
+
+Thank you for your interest in contributing to D-SafeLogger!
+This project prioritises **stability, zero-dependency purity, and architectural clarity** above all else.
+Every change is evaluated against those pillars — please read this guide before opening an issue or pull request.
+
+## 1. Understand the Design Principles
+
+Before contributing, familiarise yourself with the **Compatibility** and **Non-Goals** sections in
+[README.md](README.md). D-SafeLogger is a drop-in enhancement for Python's standard `logging`
+module, and its scope is intentionally narrow.
+
+## 2. Contribution Flow: Issue-First Policy
+
+1. **Open an Issue or Discussion first** — describe what you want to change and why.
+2. **Wait for consensus** — a maintainer will triage and discuss feasibility.
+3. **PRs by invitation** — once the issue is accepted, you will be invited to submit a PR.
+
+> ⚠️ **Unsolicited pull requests** (those without a prior accepted issue) **may be closed without review.**
+> This is not meant to discourage contributions — it ensures every change aligns with the project's direction.
+
+## 3. Where to Start?
+
+### Directly Welcome (Open an Issue)
+
+- **Bug reports** — include a minimal reproducible example, Python version, and OS.
+- **Documentation improvements** — typo fixes, clarifications, better examples.
+- **Security concerns** — please report responsibly via [SECURITY.md](SECURITY.md) or private disclosure.
+
+### Requires Discussion First
+
+- **Features not in current scope** — propose in a Discussion before writing code.
+- **Architecture changes** — structural modifications need explicit design approval.
+- **New dependencies** — almost certainly rejected. D-SafeLogger follows a strict **zero-dependency policy**.
+
+## 4. Core Constraints
+
+All contributions **must** respect these invariants:
+
+1. **Zero-dependency** — Python standard library only. No exceptions.
+2. **Fail-fast configuration** — errors must raise immediately, not fail silently.
+3. **Thread safety** — all shared state protected by explicit locks (no GIL reliance).
+4. **Append-only invariant** — log files must never be renamed or truncated.
+5. **`logging` compatibility** — must remain a drop-in enhancement for stdlib `logging`.
+
+## 5. Development Setup
+
+```bash
+git clone https://github.com/<your-username>/D-SafeLogger.git
+cd D-SafeLogger
+uv sync --group dev
+uv run pytest tests/ -v
+uv run ruff check src/ tests/
+```
+
+## 6. Code Style
+
+- **PEP 8**, max **100** characters per line.
+- **ruff** for linting (`uv run ruff check src/ tests/`).
+- **Type hints required** — use Python 3.11+ `X | Y` union syntax.
+
+## 7. Pull Request Process
+
+1. Create a feature branch from `main`.
+2. Add tests for new functionality.
+3. Ensure **all** tests pass: `uv run pytest tests/ -v`.
+4. Update documentation if needed.
+5. Submit a PR with a clear description referencing the accepted issue.
+
+## License
+
+By contributing, you agree that your contributions will be licensed under the
+[Apache License 2.0](LICENSE).
+
+---
+
+*D-SafeLogger is currently in a **stability-first phase**.
+New features are accepted conservatively — quality and reliability come first.*

d_safelogger-0.2.0/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding any notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 D
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

d_safelogger-0.2.0/MANIFEST.in

@@ -0,0 +1,60 @@
+include LICENSE
+include README.md
+include README_ja.md
+include CHANGELOG.md
+include TESTING.md
+include CONTRIBUTING.md
+include SECURITY.md
+include BENCHMARK.md
+include pyproject.toml
+include uv.lock
+
+graft docs
+graft examples
+graft tests
+graft benchmarks/summary
+
+# Summary regeneration/check scripts required for verifying selected summaries
+# from the sdist without the full benchmark runner set.
+include benchmarks/_benchmark_report.py
+include benchmarks/update_summary.py
+
+# Selected-session raw summaries referenced by benchmarks/summary/manifest.json.
+# Required for `python benchmarks/update_summary.py --check` to pass from sdist.
+include benchmarks/results/benchmark_20260506_180018/summary.json
+include benchmarks/results/benchmark_20260506_180018/summary.md
+include benchmarks/results/benchmarks_multi_integ_20260506_185947/summary.json
+include benchmarks/results/benchmarks_multi_integ_20260506_185947/summary.md
+include benchmarks/results/benchmarks_multi_perf_20260506_190518/summary.json
+include benchmarks/results/benchmarks_multi_perf_20260506_190518/summary.md
+include benchmarks/results/benchmarks_multi_resilience_20260506_211129/summary.json
+include benchmarks/results/benchmarks_multi_resilience_20260506_211129/summary.md
+
+prune .claude
+prune .github
+prune .pytest_cache
+prune .ruff_cache
+prune .venv
+prune .venv_311
+prune .verify_task
+prune _examples_extracted
+prune _src_extracted
+prune _tests_extracted
+prune build
+prune dist
+prune docs/design/old
+prune plan
+prune tests/__pycache__
+
+exclude App.log
+exclude BENCHMARK_anomaly_*.md
+exclude BENCHMARK_legacy_*.md
+exclude _gen_api_docs.py
+exclude *.zip
+global-exclude __pycache__
+global-exclude *.py[cod]
+global-exclude *.pyc.*
+global-exclude .DS_Store
+global-exclude Thumbs.db
+global-exclude .coverage
+global-exclude coverage.xml