dynatrace-openfeature-provider-python 0.0.2__tar.gz

dynatrace_openfeature_provider_python-0.0.2/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 Dynatrace LLC
+
+   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.

dynatrace_openfeature_provider_python-0.0.2/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: dynatrace-openfeature-provider-python
+Version: 0.0.2
+Summary: The official Dynatrace OpenFeature provider for Python
+Keywords: openfeature,dynatrace,feature-flags,feature-management
+Author: Dynatrace
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Requires-Dist: openfeature-sdk>=0.8.2
+Requires-Dist: openfeature-flagd-core>=1.0.0,<2.0.0
+Requires-Dist: requests>=2.27.0
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/Dynatrace/openfeature-provider-python
+Description-Content-Type: text/markdown
+
+# Dynatrace OpenFeature Provider for Python
+
+The official [Dynatrace](https://dynatrace.com) [OpenFeature](https://openfeature.dev) provider for Python server-side applications.
+
+> **Status:** Early alpha — not yet ready for production use.
+
+## Installation
+
+```bash
+pip install dynatrace-openfeature-provider-python
+```
+
+## Usage
+
+```python
+from openfeature import api
+from openfeature.evaluation_context import EvaluationContext
+from dynatrace.openfeature import DynatraceProvider, DynatraceProviderOptions
+
+options = DynatraceProviderOptions.from_sdk_key(
+    'dt01.server_us_<key>.de848e97..._a1b2c3d4e5'
+)
+
+api.set_provider(DynatraceProvider(options))
+client = api.get_client()
+
+ctx = EvaluationContext(targeting_key='user-123')
+enabled = client.get_boolean_value('my-feature', False, ctx)
+
+# On shutdown:
+api.shutdown()
+```
+
+### CDN base URL override (labs / dev environments)
+
+```python
+options = DynatraceProviderOptions.from_sdk_key(sdk_key)
+```
+
+## Architecture
+
+The provider performs in-process flag evaluation using [flagd-core](https://github.com/open-feature/python-sdk-contrib/tree/main/tools/openfeature-flagd-core).
+On initialization it fetches a flagd-format JSON config from the Dynatrace CDN and polls for
+updates every 10 seconds. No external bucketing API is called during evaluation.
+
+State transitions follow [providers.md §4.1](https://github.com/Dynatrace/feature-management-knowledge-base):
+`NOT_READY → READY → STALE → ERROR`, with a 1-minute grace period before STALE → ERROR.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+Apache 2.0 — see [LICENSE](LICENSE).

dynatrace_openfeature_provider_python-0.0.2/README.md

@@ -0,0 +1,55 @@
+# Dynatrace OpenFeature Provider for Python
+
+The official [Dynatrace](https://dynatrace.com) [OpenFeature](https://openfeature.dev) provider for Python server-side applications.
+
+> **Status:** Early alpha — not yet ready for production use.
+
+## Installation
+
+```bash
+pip install dynatrace-openfeature-provider-python
+```
+
+## Usage
+
+```python
+from openfeature import api
+from openfeature.evaluation_context import EvaluationContext
+from dynatrace.openfeature import DynatraceProvider, DynatraceProviderOptions
+
+options = DynatraceProviderOptions.from_sdk_key(
+    'dt01.server_us_<key>.de848e97..._a1b2c3d4e5'
+)
+
+api.set_provider(DynatraceProvider(options))
+client = api.get_client()
+
+ctx = EvaluationContext(targeting_key='user-123')
+enabled = client.get_boolean_value('my-feature', False, ctx)
+
+# On shutdown:
+api.shutdown()
+```
+
+### CDN base URL override (labs / dev environments)
+
+```python
+options = DynatraceProviderOptions.from_sdk_key(sdk_key)
+```
+
+## Architecture
+
+The provider performs in-process flag evaluation using [flagd-core](https://github.com/open-feature/python-sdk-contrib/tree/main/tools/openfeature-flagd-core).
+On initialization it fetches a flagd-format JSON config from the Dynatrace CDN and polls for
+updates every 10 seconds. No external bucketing API is called during evaluation.
+
+State transitions follow [providers.md §4.1](https://github.com/Dynatrace/feature-management-knowledge-base):
+`NOT_READY → READY → STALE → ERROR`, with a 1-minute grace period before STALE → ERROR.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+Apache 2.0 — see [LICENSE](LICENSE).

dynatrace_openfeature_provider_python-0.0.2/pyproject.toml

@@ -0,0 +1,109 @@
+[build-system]
+requires = ["uv_build~=0.10.0"]
+build-backend = "uv_build"
+
+[project]
+name = "dynatrace-openfeature-provider-python"
+version = "0.0.2"
+description = "The official Dynatrace OpenFeature provider for Python"
+readme = "README.md"
+authors = [{ name = "Dynatrace" }]
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+classifiers = [
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: Apache Software License",
+]
+keywords = ["openfeature", "dynatrace", "feature-flags", "feature-management"]
+dependencies = [
+    "openfeature-sdk>=0.8.2",
+    "openfeature-flagd-core>=1.0.0,<2.0.0",
+    "requests>=2.27.0",
+]
+requires-python = ">=3.10"
+
+[project.urls]
+Homepage = "https://github.com/Dynatrace/openfeature-provider-python"
+
+[dependency-groups]
+dev = [
+    "coverage[toml]>=7.10.0,<8.0.0",
+    "mypy>=1.18.0,<2.0.0",
+    "poethepoet>=0.37.0",
+    "pytest>=9.0.0,<10.0.0",
+    "responses>=0.25.0,<1.0.0",
+    "pre-commit>=4.0.0",
+    "ruff>=0.15.13",
+    "types-requests>=2.32.0,<3.0.0",
+]
+
+[tool.uv.build-backend]
+module-name = "dynatrace"
+module-root = "src"
+namespace = true
+
+[tool.coverage.run]
+omit = ["tests/**"]
+
+[tool.mypy]
+mypy_path = "src"
+files = "src"
+python_version = "3.10"
+namespace_packages = true
+explicit_package_bases = true
+local_partial_types = true
+allow_redefinition_new = true
+fixed_format_cache = true
+pretty = true
+strict = true
+disallow_any_generics = false
+
+[tool.ruff]
+target-version = "py310"
+exclude = [".git", ".venv", "__pycache__", "venv"]
+
+[tool.ruff.lint]
+select = [
+    "A", "B", "C4", "C90", "E", "F", "FLY", "FURB", "I", "ICN003",
+    "LOG", "N", "PERF", "PGH", "PLC", "PLR0913", "PLR0915",
+    "RUF", "S", "SIM", "T10", "T20", "TID251", "UP", "W", "YTT",
+]
+ignore = ["E501"]
+
+[tool.ruff.lint.per-file-ignores]
+"**/tests/**/*" = ["S101"]
+
+[tool.ruff.lint.flake8-import-conventions]
+banned-from = ["typing"]
+
+[tool.ruff.lint.flake8-tidy-imports.banned-api]
+"typing.Awaitable".msg = "Use collections.abc.Awaitable instead"
+"typing.Callable".msg = "Use collections.abc.Callable instead"
+"typing.Collection".msg = "Use collections.abc.Collection instead"
+"typing.Mapping".msg = "Use collections.abc.Mapping instead"
+"typing.MutableMapping".msg = "Use collections.abc.MutableMapping instead"
+"typing.MutableSequence".msg = "Use collections.abc.MutableSequence instead"
+"typing.Sequence".msg = "Use collections.abc.Sequence instead"
+
+[tool.ruff.lint.isort]
+known-first-party = ["dynatrace"]
+
+[tool.ruff.lint.pylint]
+max-args = 8
+max-statements = 30
+
+[tool.ruff.lint.pyupgrade]
+keep-runtime-typing = true
+
+[tool.pytest.ini_options]
+strict = true
+
+[tool.poe.tasks]
+test = "pytest tests"
+test-cov = "coverage run -m pytest tests"
+cov-report = "coverage xml"
+cov = ["test-cov", "cov-report"]
+mypy = "mypy"
+lint = "ruff check src tests"
+fmt = "ruff format src tests"

dynatrace_openfeature_provider_python-0.0.2/src/dynatrace/openfeature/__init__.py

@@ -0,0 +1,5 @@
+from .options import DynatraceProviderOptions
+from .provider import DynatraceProvider
+
+__version__ = "0.0.1"
+__all__ = ["DynatraceProvider", "DynatraceProviderOptions"]

dynatrace_openfeature_provider_python-0.0.2/src/dynatrace/openfeature/_cdn.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+import logging
+import threading
+import time
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import datetime
+from email.utils import parsedate_to_datetime
+
+import requests
+
+from ._retry import RetryStrategy, default_should_retry_status
+from .options import DynatraceProviderOptions
+
+log = logging.getLogger(__name__)
+
+REQUEST_TIMEOUT_S: float = 5.0
+_DEFAULT_RETRY_AFTER_MS: float = 60_000.0
+
+
+@dataclass
+class FetchResult:
+    status: int
+    body: str | None
+    etag: str | None
+    last_modified: str | None
+    skipped: bool = False
+
+    @property
+    def is_not_modified(self) -> bool:
+        return self.status == 304
+
+    @property
+    def is_rate_limited(self) -> bool:
+        return self.status == 429
+
+    @property
+    def is_success(self) -> bool:
+        return 200 <= self.status < 300
+
+
+@dataclass
+class _CacheState:
+    etag: str | None = None
+    last_modified_header: str | None = None
+    last_modified_at: datetime | None = None
+
+
+def _should_retry_fetch(result: FetchResult) -> bool:
+    return default_should_retry_status(result.status)
+
+
+class CdnFetcher:
+    def __init__(
+        self,
+        options: DynatraceProviderOptions,
+        retry_strategy: RetryStrategy | None = None,
+        *,
+        clock: Callable[[], float] | None = None,
+    ) -> None:
+        self._url = options.cdn_url
+        self._retry = retry_strategy or RetryStrategy()
+        self._session = requests.Session()
+        self._clock: Callable[[], float] = clock or time.time
+        self._cache = _CacheState()
+        self._rate_limited_until: float = 0.0
+        self._fetch_lock = threading.RLock()
+
+    def is_rate_limited(self, now: float | None = None) -> bool:
+        t = now if now is not None else self._clock()
+        return t < self._rate_limited_until
+
+    def fetch(self, cancel: threading.Event | None = None) -> FetchResult:
+        if self.is_rate_limited():
+            log.debug("rate limited; skipping fetch")
+            return FetchResult(429, None, None, None)
+        if not self._fetch_lock.acquire(blocking=False):
+            log.debug("fetch already in progress; skipping")
+            return FetchResult(0, None, None, None, skipped=True)
+        try:
+            return self._retry.execute(
+                self._do_fetch,
+                should_retry=_should_retry_fetch,
+                retryable_exceptions=(OSError, requests.RequestException),
+                cancel=cancel,
+            )
+        finally:
+            self._fetch_lock.release()
+
+    def _do_fetch(self) -> FetchResult:
+        cache = self._cache
+        headers: dict[str, str] = {}
+        if cache.etag is not None:
+            headers["If-None-Match"] = cache.etag
+        if cache.last_modified_header is not None:
+            headers["If-Modified-Since"] = cache.last_modified_header
+
+        try:
+            resp = self._session.get(
+                self._url,
+                headers=headers,
+                timeout=REQUEST_TIMEOUT_S,
+            )
+        except requests.RequestException:
+            raise
+
+        if resp.status_code == 304:
+            return FetchResult(304, None, cache.etag, cache.last_modified_header)
+
+        if resp.status_code == 429:
+            retry_after = resp.headers.get("Retry-After")
+            delay_ms = _parse_retry_after_ms(retry_after, self._clock())
+            self._rate_limited_until = self._clock() + delay_ms / 1000.0
+            log.warning("rate limited (429); pausing fetches for %.0fms", delay_ms)
+            return FetchResult(429, None, None, None)
+
+        new_etag = resp.headers.get("ETag")
+        new_last_modified = resp.headers.get("Last-Modified")
+        body = resp.text
+
+        if resp.status_code >= 200 and resp.status_code < 300:
+            new_lm_at = _parse_http_date(new_last_modified)
+            if (
+                new_lm_at is not None
+                and cache.last_modified_at is not None
+                and not new_lm_at > cache.last_modified_at
+            ):
+                log.warning(
+                    "CDN returned 200 but Last-Modified (%s) is not later than stored (%s);"
+                    " treating as 304 (suspected stale node)",
+                    new_last_modified,
+                    cache.last_modified_header,
+                )
+                return FetchResult(304, None, cache.etag, cache.last_modified_header)
+            self._cache = _CacheState(
+                etag=new_etag,
+                last_modified_header=new_last_modified,
+                last_modified_at=new_lm_at,
+            )
+
+        return FetchResult(resp.status_code, body, new_etag, new_last_modified)
+
+
+def _parse_http_date(value: str | None) -> datetime | None:
+    if not value:
+        return None
+    try:
+        return parsedate_to_datetime(value.strip())
+    except Exception:
+        log.warning("unparseable HTTP-date %r", value)
+        return None
+
+
+def _parse_retry_after_ms(retry_after: str | None, now: float) -> float:
+    if not retry_after or not retry_after.strip():
+        return _DEFAULT_RETRY_AFTER_MS
+    try:
+        return float(retry_after.strip()) * 1000.0
+    except ValueError:
+        pass
+    try:
+        dt = parsedate_to_datetime(retry_after.strip())
+        return max((dt.timestamp() - now) * 1000.0, 0.0)
+    except Exception:
+        log.warning("unparseable Retry-After %r; using default", retry_after)
+    return _DEFAULT_RETRY_AFTER_MS

dynatrace_openfeature_provider_python-0.0.2/src/dynatrace/openfeature/_polling.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import logging
+import threading
+import time
+from collections.abc import Callable
+
+from ._cdn import FetchResult
+
+log = logging.getLogger(__name__)
+
+
+class PollingManager:
+    """
+    Polls on a fixed-rate schedule anchored to request initiation, not completion.
+
+    A ticker thread fires every interval_s regardless of how long the previous
+    fetch took. When the ticker fires it cancels any in-flight poll and starts a
+    fresh one on a worker thread. Cancelled polls are silent: no emitFailure is
+    called.
+    """
+
+    def __init__(
+        self,
+        fetch_flags: Callable[[threading.Event | None], FetchResult],
+        store_flags: Callable[[str], list[str]],
+        emit_change: Callable[[list[str]], None],
+        emit_success: Callable[[], None],
+        emit_failure: Callable[[str], None],
+        interval_s: float,
+    ) -> None:
+        self._fetch_flags = fetch_flags
+        self._store_flags = store_flags
+        self._emit_change = emit_change
+        self._emit_success = emit_success
+        self._emit_failure = emit_failure
+        self._interval_s = interval_s
+        self._stop_event = threading.Event()
+        self._current_cancel: threading.Event | None = None
+        self._ticker_thread: threading.Thread | None = None
+
+    def start(self) -> None:
+        if self._ticker_thread is not None and self._ticker_thread.is_alive():
+            return
+        self._stop_event.clear()
+        self._ticker_thread = threading.Thread(
+            target=self._ticker_loop,
+            name="dt-provider-ticker",
+            daemon=True,
+        )
+        self._ticker_thread.start()
+
+    def stop(self) -> None:
+        self._stop_event.set()
+        if self._ticker_thread is not None:
+            self._ticker_thread.join(timeout=2.0)
+        cancel = self._current_cancel
+        if cancel is not None:
+            cancel.set()
+
+    def _ticker_loop(self) -> None:
+        next_tick = time.monotonic() + self._interval_s
+        while not self._stop_event.is_set():
+            wait = max(0.0, next_tick - time.monotonic())
+            if self._stop_event.wait(wait):
+                break
+            next_tick += self._interval_s
+            now = time.monotonic()
+            if next_tick < now:
+                next_tick = now + self._interval_s
+            self._dispatch()
+
+    def _dispatch(self) -> None:
+        if self._stop_event.is_set():
+            return
+        prev = self._current_cancel
+        if prev is not None:
+            prev.set()
+        cancel = threading.Event()
+        self._current_cancel = cancel
+        threading.Thread(
+            target=self._poll,
+            args=(cancel,),
+            name="dt-provider-poller",
+            daemon=True,
+        ).start()
+
+    def _poll(self, cancel: threading.Event) -> None:
+        try:
+            result = self._fetch_flags(cancel)
+
+            if cancel.is_set():
+                log.debug("poll cancelled after fetch returned; discarding result")
+                return
+
+            if result.skipped:
+                log.debug("fetch skipped (lock contention); retaining cached state")
+                return
+
+            if result.is_not_modified:
+                log.debug("flags not modified")
+                self._emit_success()
+                return
+
+            if result.is_rate_limited:
+                log.debug("rate limited; serving cached values")
+                return
+
+            if not result.is_success:
+                self._emit_failure(f"HTTP {result.status}")
+                return
+
+            body = result.body
+            if not body:
+                self._emit_failure("empty response body")
+                return
+
+            changed_keys = self._store_flags(body)
+            self._emit_success()
+
+            if changed_keys:
+                log.info("flag configuration changed: %s", changed_keys)
+                self._emit_change(changed_keys)
+
+        except Exception as exc:
+            if cancel.is_set():
+                log.debug("poll cancelled")
+                return
+            log.warning("poll failed: %s", type(exc).__name__)
+            self._emit_failure(type(exc).__name__)

dynatrace_openfeature_provider_python-0.0.2/src/dynatrace/openfeature/_retry.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import logging
+import threading
+import time
+import typing
+from collections.abc import Callable
+from random import Random
+
+log = logging.getLogger(__name__)
+
+T = typing.TypeVar("T")
+
+_MAX_ATTEMPTS = 5
+_BASE_DELAY_MS = 100.0
+_MULTIPLIER = 2.0
+_MAX_JITTER_FACTOR = 0.20
+
+
+class RetryStrategy:
+    def __init__(self, rng: Random | None = None) -> None:
+        self._rng = rng or Random()  # noqa: S311
+
+    def execute(
+        self,
+        fn: Callable[[], T],
+        should_retry: Callable[[T], bool] = lambda _: False,
+        retryable_exceptions: tuple[type[BaseException], ...] = (OSError,),
+        cancel: threading.Event | None = None,
+    ) -> T:
+        last_exception: BaseException | None = None
+        last_result: T | None = None
+        delay_ms = _BASE_DELAY_MS
+
+        for attempt in range(1, _MAX_ATTEMPTS + 1):
+            try:
+                result = fn()
+                last_result = result
+                if not should_retry(result):
+                    return result
+                log.warning(
+                    "attempt %d/%d returned retryable result; retrying",
+                    attempt,
+                    _MAX_ATTEMPTS,
+                )
+            except retryable_exceptions as exc:
+                last_exception = exc
+                log.warning(
+                    "attempt %d/%d failed: %s; retrying", attempt, _MAX_ATTEMPTS, exc
+                )
+            except Exception as exc:
+                raise OSError("unexpected error during fetch") from exc
+
+            if attempt < _MAX_ATTEMPTS:
+                delay_ms = self._backoff(delay_ms, cancel)
+                if cancel is not None and cancel.is_set():
+                    break
+
+        if last_result is not None:
+            return last_result
+        if last_exception is not None:
+            raise last_exception
+        raise OSError("all retry attempts failed")
+
+    def _backoff(self, delay_ms: float, cancel: threading.Event | None) -> float:
+        jitter = delay_ms * self._rng.random() * _MAX_JITTER_FACTOR
+        sleep_ms = delay_ms + jitter
+        if cancel is not None:
+            cancel.wait(sleep_ms / 1000.0)
+        else:
+            time.sleep(sleep_ms / 1000.0)
+        return delay_ms * _MULTIPLIER
+
+
+def default_should_retry_status(status: int) -> bool:
+    return 500 <= status < 600

dynatrace_openfeature_provider_python-0.0.2/src/dynatrace/openfeature/options.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import re
+
+# SDK key format per providers.md §3.0:
+# {token}.server_{geo}_{publicRandom}.{secret}_{sha1}
+_KEY_PATTERN = re.compile(
+    r"^(dt[0-9]{2})\.(server)_([a-z]{2,})_([a-zA-Z0-9]{10,})\.([a-fA-F0-9]{32,})_([a-f0-9]{10,})$"
+)
+
+
+class DynatraceProviderOptions:
+    __slots__ = ("_cdn_url", "_key")
+
+    def __init__(self, key: str, cdn_url: str) -> None:
+        self._key = key
+        self._cdn_url = cdn_url
+
+    @classmethod
+    def from_sdk_key(
+        cls,
+        sdk_key: str,
+        cdn_base_url: str | None = None,
+    ) -> DynatraceProviderOptions:
+        if not sdk_key or not sdk_key.strip():
+            raise ValueError("sdk_key must not be null or blank")
+        trimmed = sdk_key.strip()
+        key_match = _KEY_PATTERN.match(trimmed)
+        if not key_match:
+            last_dot = trimmed.rfind(".")
+            public_part = trimmed[:last_dot] if last_dot > 0 else "<redacted>"
+            raise ValueError(
+                f"invalid key format (public: {public_part!r}); "
+                "expected dt{NN}.server_{geo}_{rand}.{secret}_{sha}"
+            )
+        _token, _platform, geo, _rand, _secret, _sha = key_match.groups()
+        if cdn_base_url is not None:
+            cdn_base_url = cdn_base_url.strip()
+            if not cdn_base_url:
+                raise ValueError("cdn_base_url must not be blank")
+            base = cdn_base_url if cdn_base_url.endswith("/") else cdn_base_url + "/"
+        else:
+            base = f"https://cdn.{geo}.fm.dynatrace.com/server/"
+        cdn_url = base + trimmed + ".json"
+        return cls(key=trimmed, cdn_url=cdn_url)
+
+    @property
+    def public_key(self) -> str:
+        # Everything before the last '.' — safe to log; never exposes the secret segment.
+        idx = self._key.rfind(".")
+        return self._key[:idx] if idx > 0 else "<redacted>"
+
+    @property
+    def cdn_url(self) -> str:
+        return self._cdn_url

dynatrace_openfeature_provider_python-0.0.2/src/dynatrace/openfeature/provider.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+
+import logging
+import threading
+from collections.abc import Mapping, Sequence
+
+import requests
+
+from openfeature.contrib.tools.flagd.core import FlagdCore
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.event import ProviderEventDetails
+from openfeature.exception import GeneralError, ParseError
+from openfeature.flag_evaluation import FlagResolutionDetails, FlagValueType
+from openfeature.hook import Hook
+from openfeature.provider import AbstractProvider, Metadata, ProviderStatus
+
+from ._cdn import REQUEST_TIMEOUT_S as _REQUEST_TIMEOUT_S
+from ._cdn import CdnFetcher
+from ._polling import PollingManager
+from .options import DynatraceProviderOptions
+
+log = logging.getLogger(__name__)
+
+_PROVIDER_NAME = "dynatrace"
+_POLL_INTERVAL_S: float = 10.0
+_GRACE_PERIOD_S: float = 60.0
+
+
+class DynatraceProvider(AbstractProvider):
+    def __init__(
+        self,
+        sdk_key: str,
+        *,
+        cdn_base_url: str | None = None,
+        flagd_core: FlagdCore | None = None,
+        fetcher: CdnFetcher | None = None,
+        poll_interval_s: float = _POLL_INTERVAL_S,
+        grace_period_s: float = _GRACE_PERIOD_S,
+    ) -> None:
+        options = DynatraceProviderOptions.from_sdk_key(
+            sdk_key, cdn_base_url=cdn_base_url
+        )
+        if fetcher is None and poll_interval_s <= _REQUEST_TIMEOUT_S:
+            raise ValueError(
+                f"poll_interval_s ({poll_interval_s}s) must be greater than the "
+                f"request timeout ({_REQUEST_TIMEOUT_S}s)"
+            )
+        self._options = options
+        self._flagd_core = flagd_core or FlagdCore()
+        self._fetcher = fetcher or CdnFetcher(options)
+        self._poll_interval_s = poll_interval_s
+        self._grace_period_s = grace_period_s
+        self._poller: PollingManager | None = None
+        self._grace_timer: threading.Timer | None = None
+        self._state = ProviderStatus.NOT_READY
+        self._lock = threading.RLock()
+        # bumped by initialize/shutdown so a slow init can detect it was superseded
+        self._generation = 0
+
+    def get_metadata(self) -> Metadata:
+        return Metadata(name=_PROVIDER_NAME)
+
+    def get_provider_hooks(self) -> list[Hook]:
+        return []
+
+    def initialize(self, evaluation_context: EvaluationContext | None = None) -> None:
+        log.info("initializing Dynatrace provider (key=%s)", self._options.public_key)
+        with self._lock:
+            self._generation += 1
+            generation = self._generation
+
+        try:
+            result = self._fetcher.fetch()
+        except (OSError, requests.RequestException) as exc:
+            raise GeneralError(
+                f"initial CDN fetch failed: {type(exc).__name__}"
+            ) from exc
+
+        if not result.is_success:
+            raise GeneralError(f"initial CDN fetch returned HTTP {result.status}")
+
+        body = result.body
+        if not body or not body.strip():
+            raise GeneralError("initial CDN response body was empty")
+
+        try:
+            self._flagd_core.set_flags(body)
+        except ParseError as exc:
+            raise GeneralError(f"initial CDN config is invalid: {exc}") from exc
+
+        with self._lock:
+            if self._generation != generation:
+                # A concurrent shutdown() or re-initialize() superseded us while
+                # the fetch was in flight; do not resurrect the provider.
+                log.info(
+                    "initialize superseded by a concurrent shutdown/initialize; "
+                    "not starting poller"
+                )
+                return
+            self._cancel_grace_timer()
+            if self._poller is not None:
+                self._poller.stop()
+            self._state = ProviderStatus.READY
+            self._poller = PollingManager(
+                fetch_flags=self._fetcher.fetch,
+                store_flags=self._store_flags,
+                emit_change=self._on_configuration_changed,
+                emit_success=self._on_fetch_success,
+                emit_failure=self._on_fetch_failure,
+                interval_s=self._poll_interval_s,
+            )
+            self._poller.start()
+        log.info("Dynatrace provider initialized successfully")
+
+    def shutdown(self) -> None:
+        with self._lock:
+            # Always bump the generation, even when already idle, so an
+            # in-flight initialize() detects it was superseded and aborts.
+            self._generation += 1
+            if self._state == ProviderStatus.NOT_READY and self._poller is None:
+                return
+            log.info("shutting down Dynatrace provider")
+            self._state = ProviderStatus.NOT_READY
+            self._cancel_grace_timer()
+            if self._poller is not None:
+                self._poller.stop()
+                self._poller = None
+        super().shutdown()
+        log.info("Dynatrace provider shut down")
+
+    def resolve_boolean_details(
+        self,
+        flag_key: str,
+        default_value: bool,
+        evaluation_context: EvaluationContext | None = None,
+    ) -> FlagResolutionDetails[bool]:
+        return self._flagd_core.resolve_boolean_value(
+            flag_key, default_value, evaluation_context
+        )
+
+    def resolve_string_details(
+        self,
+        flag_key: str,
+        default_value: str,
+        evaluation_context: EvaluationContext | None = None,
+    ) -> FlagResolutionDetails[str]:
+        return self._flagd_core.resolve_string_value(
+            flag_key, default_value, evaluation_context
+        )
+
+    def resolve_integer_details(
+        self,
+        flag_key: str,
+        default_value: int,
+        evaluation_context: EvaluationContext | None = None,
+    ) -> FlagResolutionDetails[int]:
+        return self._flagd_core.resolve_integer_value(
+            flag_key, default_value, evaluation_context
+        )
+
+    def resolve_float_details(
+        self,
+        flag_key: str,
+        default_value: float,
+        evaluation_context: EvaluationContext | None = None,
+    ) -> FlagResolutionDetails[float]:
+        return self._flagd_core.resolve_float_value(
+            flag_key, default_value, evaluation_context
+        )
+
+    def resolve_object_details(
+        self,
+        flag_key: str,
+        default_value: Sequence[FlagValueType] | Mapping[str, FlagValueType],
+        evaluation_context: EvaluationContext | None = None,
+    ) -> FlagResolutionDetails[Sequence[FlagValueType] | Mapping[str, FlagValueType]]:
+        return self._flagd_core.resolve_object_value(
+            flag_key, default_value, evaluation_context
+        )
+
+    def _store_flags(self, body: str) -> list[str]:
+        return self._flagd_core.set_flags_and_get_changed_keys(body)
+
+    def _on_fetch_success(self) -> None:
+        with self._lock:
+            if self._state == ProviderStatus.NOT_READY:
+                return
+            self._cancel_grace_timer()
+            if self._state in (ProviderStatus.STALE, ProviderStatus.ERROR):
+                prev_state = self._state
+                self._state = ProviderStatus.READY
+                log.info("recovered from %s to READY", prev_state)
+                self.emit_provider_ready(ProviderEventDetails(message="recovered"))
+
+    def _on_fetch_failure(self, reason: str) -> None:
+        with self._lock:
+            if self._state == ProviderStatus.NOT_READY:
+                return
+            if self._state == ProviderStatus.READY:
+                self._state = ProviderStatus.STALE
+                log.warning("poll failed, transitioning to STALE: %s", reason)
+                self.emit_provider_stale(ProviderEventDetails(message=reason))
+                self._start_grace_timer()
+            else:
+                log.warning("poll failed (state=%s): %s", self._state, reason)
+
+    def _on_configuration_changed(self, changed_keys: list[str]) -> None:
+        with self._lock:
+            if self._state == ProviderStatus.NOT_READY:
+                return
+            self.emit_provider_configuration_changed(
+                ProviderEventDetails(flags_changed=changed_keys)
+            )
+
+    def _start_grace_timer(self) -> None:
+        self._cancel_grace_timer()
+        t = threading.Timer(self._grace_period_s, self._grace_expired)
+        t.daemon = True
+        t.name = "dt-provider-grace-timer"
+        t.start()
+        self._grace_timer = t
+
+    def _cancel_grace_timer(self) -> None:
+        if self._grace_timer is not None:
+            self._grace_timer.cancel()
+            self._grace_timer = None
+
+    def _grace_expired(self) -> None:
+        with self._lock:
+            if self._state != ProviderStatus.STALE:
+                return
+            self._state = ProviderStatus.ERROR
+            log.error("grace period expired, transitioning to ERROR")
+            self.emit_provider_error(
+                ProviderEventDetails(message="grace period expired; CDN unreachable")
+            )