Modernize ddev create check template (DataDog#23705)

* Modernize ddev create check template to Python 3.13 idioms

- Replace Python 2-style super() call with bare super().__init__()
- Replace PEP 484 comment-form type annotations with inline annotations
- Add typed signatures to check() and __init__() using InitConfigType and
  InstanceType from datadog_checks.base.types
- Type conftest fixtures (Iterator[None], InstanceType)
- Remove noqa: F401 markers that existed only to support comment annotations
- Use dict[str, Any] instead of Dict[str, Any] in test_unit.py

* Add changelog entry for PR DataDog#23705

* Shorter changelog

* Add ConfigMixin and bump datadog-checks-base version in template

* Enable mypy in check template via hatch check-types

Enable check-types in hatch.toml so mypy runs as part of ddev test --lint
on every new integration generated from the check template. Add
--explicit-package-bases to handle the namespace package layout under
datadog_checks/.

Fix the dd_run_check fixture annotation in test_unit.py from
Callable[[AgentCheck, bool], None] (which lied about the signature and
was previously hidden inside a PEP 484 comment) to Callable[..., None],
matching the actual fixture signature run_check(check, extract_message=
False, cancel=True).

* Add test_e2e template and teaching comments for tests

Add tests/test_e2e.py to the check template so new integrations ship
with an end-to-end test from day one. The stub is gated by
@pytest.mark.e2e so it does not run under `ddev test`, only under
`ddev env test`. Live assertions cover the metadata sanity checks
(assert_metrics_using_metadata + assert_all_metrics_covered); a
commented block lists the common per-metric, per-tag and service-check
assertions.

Expand tests/test_unit.py with the same teaching-comment pattern
already used in check.py: a commented menu of assert_metric,
assert_metric_has_tag, assert_metric_has_tag_prefix and
assert_service_check.

Add a commented docker_run + CheckEndpoints example to dd_environment
in tests/conftest.py so users see the canonical setup pattern without
shipping an empty docker/ folder, which would be misleading given how
divergent real integration setups are.

* Delete servicechecks comment

* Use find_free_port in conftest docker_run example

Address review feedback: replace the hardcoded port 1234 in the
commented dd_environment example with find_free_port(get_docker_hostname()),
so users following the pattern do not collide with whatever happens to
be listening on their host.

* Move self.config to check() and rename changelog

* Change comment

* Fix README template to align with current capitalization

* Capitalize 'Checks'

Co-authored-by: Ursula Chen <58821586+urseberry@users.noreply.github.com>

* Capitalize 'Collected'

Co-authored-by: Ursula Chen <58821586+urseberry@users.noreply.github.com>

* Remove --explicit-package-bases from hatch.toml template

* Capitalize Collected

Co-authored-by: Ursula Chen <58821586+urseberry@users.noreply.github.com>

* Capitalize Checks

Co-authored-by: Ursula Chen <58821586+urseberry@users.noreply.github.com>

---------

Co-authored-by: Ursula Chen <58821586+urseberry@users.noreply.github.com>

Author: luisorofino

datadog_checks_dev/changelog.d/23705.added

@@ -0,0 +1 @@
+Modernize the `ddev create -t check` scaffold template to use Python 3.13 idioms.

datadog_checks_dev/datadog_checks/dev/tooling/templates/integration/check/{check_name}/README.md

@@ -2,7 +2,7 @@
 
 ## Overview
 
-This check monitors [{integration_name}][1] through the Datadog Agent. 
+This check monitors [{integration_name}][1] through the Datadog Agent.
 
 Include a high level overview of what this integration does:
 - What does your product do (in 1-2 sentences)?
@@ -11,7 +11,7 @@ Include a high level overview of what this integration does:
 
 ## Setup
 
-Follow the instructions below to install and configure this check for an Agent running on a host. For containerized environments, see the [Autodiscovery Integration Templates][3] for guidance on applying these instructions.
+Follow the instructions below to install and configure this check for an Agent running on a host. For containerized environments, see the [Autodiscovery integration templates][3] for guidance on applying these instructions.
 
 ### Installation
 
@@ -27,7 +27,7 @@ Follow the instructions below to install and configure this check for an Agent r
 
 [Run the Agent's status subcommand][6] and look for `{check_name}` under the Checks section.
 
-## Data Collected
+## Data collected
 
 ### Metrics
 
@@ -37,7 +37,7 @@ See [metadata.csv][7] for a list of metrics provided by this integration.
 
 The {integration_name} integration does not include any events.
 
-### Service Checks
+### Service checks
 
 The {integration_name} integration does not include any service checks.
 

datadog_checks_dev/datadog_checks/dev/tooling/templates/integration/check/{check_name}/datadog_checks/{check_name}/check.py

@@ -1,23 +1,21 @@
 {license_header}
-from typing import Any  # noqa: F401
 
-from datadog_checks.base import AgentCheck  # noqa: F401
+from datadog_checks.base import AgentCheck
+from datadog_checks.base.types import InitConfigType, InstanceType
+
+from .config_models import ConfigMixin
 
 # from datadog_checks.base.utils.db import QueryManager
 # from requests.exceptions import ConnectionError, HTTPError, InvalidURL, Timeout
 # from json import JSONDecodeError
 
 
-class {check_class}(AgentCheck):
-
+class {check_class}(AgentCheck, ConfigMixin):
     # This will be the prefix of every metric the integration sends
     __NAMESPACE__ = '{check_name}'
 
-    def __init__(self, name, init_config, instances):
-        super({check_class}, self).__init__(name, init_config, instances)
-
-        # Use self.instance to read the check configuration
-        # self.url = self.instance.get("url")
+    def __init__(self, name: str, init_config: InitConfigType, instances: list[InstanceType]) -> None:
+        super().__init__(name, init_config, instances)
 
         # If the check is going to perform SQL queries you should define a query manager here.
         # More info at
@@ -32,24 +30,27 @@ def __init__(self, name, init_config, instances):
         # self._query_manager = QueryManager(self, self.execute_query, queries=[sample_query])
         # self.check_initializations.append(self._query_manager.compile_queries)
 
-    def check(self, _):
-        # type: (Any) -> None
+    def check(self, _: InstanceType) -> None:
         # The following are useful bits of code to help new users get started.
 
+        # Read validated, typed configuration from self.config (and self.shared_config).
+        # Fields must be declared in spec.yaml and the models regenerated with `ddev validate models`.
+        # url = self.config.url
+
         # Perform HTTP Requests with our HTTP wrapper.
         # More info at https://datadoghq.dev/integrations-core/base/http/
         # try:
-        #     response = self.http.get(self.url)
+        #     response = self.http.get(url)
         #     response.raise_for_status()
         #     response_json = response.json()
 
-        # except (HTTPError, InvalidURL, ConnectionError, Timeout) as e:
+        # except (HTTPError, InvalidURL, ConnectionError, Timeout):
         #     self.log.debug("Could not connect", exc_info=True)
 
-        # except JSONDecodeError as e:
+        # except JSONDecodeError:
         #    self.log.debug("Could not parse JSON", exc_info=True)
 
-        # except ValueError as e:
+        # except ValueError:
         #    self.log.debug("Unexpected value", exc_info=True)
 
         # This is how you submit metrics
@@ -60,7 +61,7 @@ def check(self, _):
         # Perform database queries using the Query Manager
         # self._query_manager.execute()
 
-        # This is how you use the persistent cache. This cache file based and persists across agent restarts.
+        # This is how you use the persistent cache. This cache is file based and persists across agent restarts.
         # If you need an in-memory cache that is persisted across runs
         # You can define a dictionary in the __init__ method.
         # self.write_persistent_cache("key", "value")

datadog_checks_dev/datadog_checks/dev/tooling/templates/integration/check/{check_name}/hatch.toml

@@ -1,4 +1,5 @@
 [env.collectors.datadog-checks]
+check-types = true
 
 [[envs.default.matrix]]
 python = ["3.13"]

datadog_checks_dev/datadog_checks/dev/tooling/templates/integration/check/{check_name}/pyproject.toml

@@ -29,7 +29,7 @@ classifiers = [
     "Topic :: System :: Monitoring",
 ]
 dependencies = [
-    "datadog-checks-base>=37.33.0",
+    "datadog-checks-base>=37.36.0",
 ]
 dynamic = [
     "version",

datadog_checks_dev/datadog_checks/dev/tooling/templates/integration/check/{check_name}/tests/conftest.py

@@ -1,12 +1,34 @@
 {license_header}
+from typing import Iterator
+
 import pytest
 
+from datadog_checks.base.types import InstanceType
+
 
 @pytest.fixture(scope='session')
-def dd_environment():
+def dd_environment() -> Iterator[None]:
+    # When the integration has a real test environment, wire it here.
+    # Typical Docker Compose setup:
+    #
+    # from pathlib import Path
+    # from datadog_checks.dev import docker_run
+    # from datadog_checks.dev.conditions import CheckEndpoints
+    # from datadog_checks.dev.docker import get_docker_hostname
+    # from datadog_checks.dev.utils import find_free_port
+    #
+    # host = get_docker_hostname()
+    # port = find_free_port(host)
+    # compose_file = Path(__file__).parent / "docker" / "docker-compose.yml"
+    # with docker_run(
+    #     compose_file=str(compose_file),
+    #     env_vars={{"PORT": str(port)}},
+    #     conditions=[CheckEndpoints(f"http://{{host}}:{{port}}/health", attempts=60, wait=2)],
+    # ):
+    #     yield {{"instances": [{{"openmetrics_endpoint": f"http://{{host}}:{{port}}/metrics"}}]}}
     yield
 
 
 @pytest.fixture
-def instance():
+def instance() -> InstanceType:
     return {{}}

datadog_checks_dev/datadog_checks/dev/tooling/templates/integration/check/{check_name}/tests/test_e2e.py

@@ -0,0 +1,25 @@
+{license_header}
+
+from typing import Any
+
+import pytest
+
+from datadog_checks.base.types import InstanceType
+from datadog_checks.dev.utils import get_metadata_metrics
+
+
+@pytest.mark.e2e
+def test_e2e(dd_agent_check: Any, instance: InstanceType) -> None:
+    aggregator = dd_agent_check(instance, rate=True)
+
+    # Assert every metric emitted is declared in metadata.csv with the correct type and unit,
+    # and that every metric in metadata.csv was emitted at least once.
+    aggregator.assert_metrics_using_metadata(get_metadata_metrics())
+
+    # Assert no metric was emitted that wasn't covered by an assertion above.
+    aggregator.assert_all_metrics_covered()
+
+    # Other useful assertions to consider for end-to-end coverage:
+    # aggregator.assert_metric('{check_name}.<metric>', value=1.23, count=1, tags=['foo:bar'])
+    # aggregator.assert_metric_has_tag('{check_name}.<metric>', 'env:prod')
+    # aggregator.assert_metric_has_tag_prefix('{check_name}.<metric>', 'host:')

datadog_checks_dev/datadog_checks/dev/tooling/templates/integration/check/{check_name}/tests/test_unit.py

@@ -1,17 +1,37 @@
 {license_header}
 
-from typing import Any, Callable, Dict  # noqa: F401
+from typing import Callable
 
-from datadog_checks.base import AgentCheck  # noqa: F401
-from datadog_checks.base.stubs.aggregator import AggregatorStub  # noqa: F401
+from datadog_checks.base.stubs.aggregator import AggregatorStub
+from datadog_checks.base.types import InstanceType
 from datadog_checks.dev.utils import get_metadata_metrics
 from datadog_checks.{check_name} import {check_class}
 
 
-def test_check(dd_run_check, aggregator, instance):
-    # type: (Callable[[AgentCheck, bool], None], AggregatorStub, Dict[str, Any]) -> None
+def test_check(
+    dd_run_check: Callable[..., None],
+    aggregator: AggregatorStub,
+    instance: InstanceType,
+) -> None:
     check = {check_class}('{check_name}', {{}}, [instance])
     dd_run_check(check)
 
-    aggregator.assert_all_metrics_covered()
+    # Assert every metric emitted is declared in metadata.csv with the correct type and unit,
+    # and that every metric in metadata.csv was emitted.
     aggregator.assert_metrics_using_metadata(get_metadata_metrics())
+
+    # The following are useful assertions to help new users get started.
+
+    # Assert a specific metric was emitted with a specific value, count, and tag set.
+    # aggregator.assert_metric('{check_name}.<metric>', value=1.23, count=1, tags=['foo:bar'])
+
+    # Assert a metric carries a specific tag (exact match) or any tag with a given prefix.
+    # aggregator.assert_metric_has_tag('{check_name}.<metric>', 'env:prod')
+    # aggregator.assert_metric_has_tag_prefix('{check_name}.<metric>', 'host:')
+
+    # Assert a service check was emitted with a specific status.
+    # from datadog_checks.base.constants import ServiceCheck
+    # aggregator.assert_service_check('{check_name}.can_connect', ServiceCheck.OK, count=1)
+
+    # Assert nothing was emitted that wasn't covered by an assertion above.
+    aggregator.assert_all_metrics_covered()