dt-extensions-sdk 1.4.0__py3-none-any.whl → 1.5.1__py3-none-any.whl

{dt_extensions_sdk-1.4.0.dist-info → dt_extensions_sdk-1.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dt-extensions-sdk
-Version: 1.4.0
+Version: 1.5.1
 Project-URL: Documentation, https://github.com/dynatrace-extensions/dt-extensions-python-sdk#readme
 Project-URL: Issues, https://github.com/dynatrace-extensions/dt-extensions-python-sdk/issues
 Project-URL: Source, https://github.com/dynatrace-extensions/dt-extensions-python-sdk
@@ -16,6 +16,7 @@ Requires-Python: <3.11,>=3.10
 Provides-Extra: cli
 Requires-Dist: dt-cli>=1.6.13; extra == 'cli'
 Requires-Dist: pyyaml; extra == 'cli'
+Requires-Dist: ruff; extra == 'cli'
 Requires-Dist: typer[all]; extra == 'cli'
 Description-Content-Type: text/markdown
 

{dt_extensions_sdk-1.4.0.dist-info → dt_extensions_sdk-1.5.1.dist-info}/RECORD

@@ -1,35 +1,36 @@
-dynatrace_extension/__about__.py,sha256=0eF7oFPAs4l6aF4bObZHJnLcIaLQ07bZ0ozH7nzz4HY,110
+dynatrace_extension/__about__.py,sha256=5K7C4flDpJDmdHw8pNksZ4c9GLxQrwNkYMwLMvckJ-I,110
 dynatrace_extension/__init__.py,sha256=BvQuknmA7ti3WJi3zEXZfY7aAxJrie37VNitWICsUvI,752
 dynatrace_extension/cli/__init__.py,sha256=HCboY_eJPoqjFmoPDsBL8Jk6aNvank8K7JpkVrgwzUM,123
-dynatrace_extension/cli/main.py,sha256=Z8gFcp0vIMBkzV6jUd5mwvP1U0JcLqAHoMLJw_6puz4,18260
+dynatrace_extension/cli/main.py,sha256=OTjJ4XHJvvYXj10a7WFFHVNnkyECPg1ClW6Os8piN8k,20168
 dynatrace_extension/cli/schema.py,sha256=d8wKUodRiaU3hfSZDWVNpD15lBfhmif2oQ-k07IxcaA,3230
 dynatrace_extension/cli/create/__init__.py,sha256=NfyOJCVlxs8dYtfDAMHS1Q5SJTuZcFzOg5rtaI-ZPRE,72
-dynatrace_extension/cli/create/create.py,sha256=apXden2M93MDDDm7aa-Os-AEtUtyKbk_PsS56j32NK4,2708
+dynatrace_extension/cli/create/create.py,sha256=IcgyVcjud1QTUE99KNHVNTH7G0qQsQyldVchp6CG3v8,2695
 dynatrace_extension/cli/create/extension_template/.gitignore.template,sha256=FPye23W8dqmked4HQBCDCAKFf1UbBGkwhKjQpgmXhdg,3101
 dynatrace_extension/cli/create/extension_template/README.md.template,sha256=QcV0fYqJ1PHaouKdGQgzveJY5zAFBSICp7xSfgnoQj0,637
 dynatrace_extension/cli/create/extension_template/activation.json.template,sha256=qX-Fgq_JhUWNYMe1-RMcjwQPzF4scJYGfGlBr043UiY,266
+dynatrace_extension/cli/create/extension_template/ruff.toml.template,sha256=knGDPYHrdrlSDXpe3XNofcgAP-6XyzyHNqLd6Tr8bbs,1853
 dynatrace_extension/cli/create/extension_template/secrets.json.template,sha256=fr-ya8lR0TiUmr6lf-PFko6RZw6sr54FxtMbqIWBVkA,36
-dynatrace_extension/cli/create/extension_template/setup.py.template,sha256=M4HPg3UFkvmWFHAz6vHbDG5Ocb-ZiR0TQuLt9eedW1M,846
+dynatrace_extension/cli/create/extension_template/setup.py.template,sha256=CPSx_mRKP6R273wFN-tJFQEsMNF2ktSO-I58mAWLM9M,829
 dynatrace_extension/cli/create/extension_template/extension/activationSchema.json.template,sha256=me3DL_Q449q4VaOStTqaBL-gUkKnlafC8L2093O0LOY,2905
 dynatrace_extension/cli/create/extension_template/extension/extension.yaml.template,sha256=qDyAURGXKsZBIPjW2s1BPhD-xOC8_FoBgA33HbsOkAU,299
 dynatrace_extension/cli/create/extension_template/extension_name/__init__.py.template,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dynatrace_extension/cli/create/extension_template/extension_name/__main__.py.template,sha256=NYuZ6BWZ6HOs4TCuboh6S0nuYp3F8MXW2lmjSpdREEA,1205
+dynatrace_extension/cli/create/extension_template/extension_name/__main__.py.template,sha256=cS79GVxJB-V-gocu4ZOjmZ54HXJNg89eXdLf89zDHJQ,1249
 dynatrace_extension/sdk/__init__.py,sha256=RsqQ1heGyCmSK3fhuEKAcxQIRCg4gEK0-eSkIehL5Nc,86
-dynatrace_extension/sdk/activation.py,sha256=goTbT1tD2kn8xfyXFdTy_cTZNcFPJpgbvQM8HOzKECA,1480
-dynatrace_extension/sdk/callback.py,sha256=eMpC0F3fCI82mWHIFgmy9QmKl7Kq_9dSaanHdV6o7hA,6511
-dynatrace_extension/sdk/communication.py,sha256=QkJgEBblOen-jmvsb3ZfYZYglYUc7jHbkEgPtRj9l6w,19123
+dynatrace_extension/sdk/activation.py,sha256=KIoPWMZs3tKiMG8XhCfeNgRlz2vxDKcAASgSACcEfIQ,1456
+dynatrace_extension/sdk/callback.py,sha256=--GyC5aDAhgRix8QLHHvp7KjYMIECTecy9jJWX0wyj8,6488
+dynatrace_extension/sdk/communication.py,sha256=_u3VdftaI8N59Qxjtn9H0pJetWMhhrC6fNLPEixHmFw,19142
 dynatrace_extension/sdk/event.py,sha256=J261imbFKpxfuAQ6Nfu3RRcsIQKKivy6fme1nww2g-8,388
-dynatrace_extension/sdk/extension.py,sha256=59hg3aUXbrkhvEB7za8jujv1LZQ4sSx4ot9scijadQU,44926
-dynatrace_extension/sdk/helper.py,sha256=ZNrO9ao2hE3KQ934vAYD74k0fCr6QTG-_bAvbk9-hi8,6562
-dynatrace_extension/sdk/metric.py,sha256=7VClzJCFJNDCxA-d69uTu1pdPtDZBTwq7fbafs_L6nQ,3690
-dynatrace_extension/sdk/runtime.py,sha256=jyYsM1x-gMnW68eWq8IoZZZBarHgIcr_nVeGDDgpRDk,2802
-dynatrace_extension/sdk/snapshot.py,sha256=0Zx4lmhanoLvfvMTnkxWfcIsx2VUDm99FAqV0XZHoLA,7100
+dynatrace_extension/sdk/extension.py,sha256=2mFDECsqZziYLGuxY3sYoVyWfWlhgc0ZUYwuUiXJQaA,45192
+dynatrace_extension/sdk/helper.py,sha256=m4gGHtIKYkfANC2MOGdxKUZlmH5tnZO6WTNqll27lyY,6476
+dynatrace_extension/sdk/metric.py,sha256=-kq7JWpk7UGvcjqafTt-o6k4urwhsGVXmnuQg7Sf9PQ,3622
+dynatrace_extension/sdk/runtime.py,sha256=7bC4gUJsVSHuL_E7r2EWrne95nm1BjZiMGkyNqA7ZCU,2796
+dynatrace_extension/sdk/snapshot.py,sha256=LnWVCtCK4NIEV3_kX-ly_LGHpNBSeErtsxCI1PH3L28,7521
 dynatrace_extension/sdk/vendor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dynatrace_extension/sdk/vendor/mureq/LICENSE,sha256=8AVcgZgiT_mvK1fOofXtRRr2f1dRXS_K21NuxQgP4VM,671
 dynatrace_extension/sdk/vendor/mureq/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dynatrace_extension/sdk/vendor/mureq/mureq.py,sha256=znF4mvzk5L03CLNozRz8UpK-fMijmSkObDFwlbhwLUg,14656
-dt_extensions_sdk-1.4.0.dist-info/METADATA,sha256=LYTXYtBm33nrBL_jz22oNjpB0mRIhIdr27pFuHgNzao,2685
-dt_extensions_sdk-1.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dt_extensions_sdk-1.4.0.dist-info/entry_points.txt,sha256=pweyOCgENGHjOlT6_kXYaBPOrE3p18K0UettqnNlnoE,55
-dt_extensions_sdk-1.4.0.dist-info/licenses/LICENSE.txt,sha256=3Zihv0lOVYHNfDkJC-tUAU6euP9r2NexsDW4w-zqgVk,1078
-dt_extensions_sdk-1.4.0.dist-info/RECORD,,
+dt_extensions_sdk-1.5.1.dist-info/METADATA,sha256=ItVzENof2_FYkmDls53v9pCU8hexGrmaQDRkPc2BBuE,2721
+dt_extensions_sdk-1.5.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dt_extensions_sdk-1.5.1.dist-info/entry_points.txt,sha256=pweyOCgENGHjOlT6_kXYaBPOrE3p18K0UettqnNlnoE,55
+dt_extensions_sdk-1.5.1.dist-info/licenses/LICENSE.txt,sha256=3Zihv0lOVYHNfDkJC-tUAU6euP9r2NexsDW4w-zqgVk,1078
+dt_extensions_sdk-1.5.1.dist-info/RECORD,,

dynatrace_extension/__about__.py

@@ -3,4 +3,4 @@
 # SPDX-License-Identifier: MIT
 
 
-__version__ = "1.4.0"
+__version__ = "1.5.1"

dynatrace_extension/cli/create/create.py

@@ -2,7 +2,7 @@ import os
 import re
 import shutil
 from pathlib import Path
-from typing import Final, List, NamedTuple, Tuple
+from typing import Final, NamedTuple
 
 output_mode_folder: Final = 0o755
 output_mode_file: Final = 0o644
@@ -14,7 +14,7 @@ class ReplaceString(NamedTuple):
     replace: str
 
 
-def replace_placeholders(file: Path, replaces: List[Tuple[str, str]]):
+def replace_placeholders(file: Path, replaces: list[tuple[str, str]]):
     with open(file) as f:
         contents = f.read()
     for replace in replaces:

dynatrace_extension/cli/create/extension_template/extension_name/__main__.py.template

@@ -2,7 +2,6 @@ from dynatrace_extension import Extension, Status, StatusValue
 
 
 class ExtensionImpl(Extension):
-
     def query(self):
         """
         The query method is automatically scheduled to run every minute
@@ -11,22 +10,24 @@ class ExtensionImpl(Extension):
 
         for endpoint in self.activation_config["endpoints"]:
             url = endpoint["url"]
-            user = endpoint["user"]
-            password = endpoint["password"]
+            # user = endpoint["user"]
+            # password = endpoint["password"]
             self.logger.debug(f"Running endpoint with url '{url}'")
 
             # Your extension code goes here, e.g.
             # response = requests.get(url, auth=(user, password))
 
             # Report metrics with
-            self.report_metric("my_metric", 1, dimensions={"my_dimension": "dimension1"})
+            self.report_metric("metric_key", 1, dimensions={"key": "value"})
 
         self.logger.info("query method ended for %extension_name%.")
 
     def fastcheck(self) -> Status:
         """
-        This is called when the extension runs for the first time.
-        If this AG cannot run this extension, raise an Exception or return StatusValue.ERROR!
+        Use to check if the extension can run.
+        If this Activegate cannot run this extension, you can
+        raise an Exception or return StatusValue.ERROR.
+        This does not run for OneAgent extensions.
         """
         return Status(StatusValue.OK)
 
@@ -35,6 +36,5 @@ def main():
     ExtensionImpl(name="%extension_name%").run()
 
 
-
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

dynatrace_extension/cli/create/extension_template/ruff.toml.template

@@ -0,0 +1,77 @@
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".ipynb_checkpoints",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pyenv",
+    ".pytest_cache",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    ".vscode",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "site-packages",
+    "venv",
+    "windows.py", # windows run as
+    "windows_runas.py", # windows run as
+    "*grpc.py", # automatically generated grpc files
+    "mureq.py", # a replacement for requests
+    "vendor", # vendored dependencies
+    "alembic", # alembic migrations
+    "oci", # special case for an extension
+    "pymqi", # special case for an extension
+    "lib" # some extensions commit a lib folder
+]
+
+line-length = 110
+indent-width = 4
+
+# Assume Python 3.10
+target-version = "py310"
+
+[lint]
+select = ["E", "F", "W", "C90", "I", "N", "UP", "B", "A", "FA", "T20", "Q", "RET", "SIM", "ARG", "PTH", "C"]
+ignore = [
+    "T201", # we allow print because these are logged into the extension logs
+     "PTH123" # open is used too frequently to open files
+]
+
+# Allow fix for all enabled rules (when `--fix`) is provided.
+fixable = ["ALL"]
+unfixable = []
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[lint.mccabe]
+# Flag errors (`C901`) whenever the complexity level exceeds 20.
+max-complexity = 20
+
+[format]
+# Like Black, use double quotes for strings.
+quote-style = "double"
+
+# Like Black, indent with spaces, rather than tabs.
+indent-style = "space"
+
+# Like Black, respect magic trailing commas.
+skip-magic-trailing-comma = false
+
+# Like Black, automatically detect the appropriate line ending.
+line-ending = "auto"
+
+docstring-code-format = false
+docstring-code-line-length = "dynamic"

dynatrace_extension/cli/create/extension_template/setup.py.template

@@ -1,5 +1,6 @@
 from pathlib import Path
-from setuptools import setup, find_packages
+
+from setuptools import find_packages, setup
 
 
 def find_version() -> str:
@@ -9,20 +10,21 @@ def find_version() -> str:
         with open(extension_yaml_path, encoding="utf-8") as f:
             for line in f:
                 if line.startswith("version"):
-                    version = line.split(" ")[-1].strip("\"")
+                    version = line.split(" ")[-1].strip('"')
                     break
     except Exception:
         pass
     return version
 
 
-setup(name="%extension_name%",
-      version=find_version(),
-      description="%Extension_Name% python EF2 extension",
-      author="Dynatrace",
-      packages=find_packages(),
-      python_requires=">=3.10",
-      include_package_data=True,
-      install_requires=["dt-extensions-sdk"],
-      extras_require={"dev": ["dt-extensions-sdk[cli]"]},
-      )
+setup(
+    name="%extension_name%",
+    version=find_version(),
+    description="%Extension_Name% python EF2 extension",
+    author="Dynatrace",
+    packages=find_packages(),
+    python_requires=">=3.10",
+    include_package_data=True,
+    install_requires=["dt-extensions-sdk"],
+    extras_require={"dev": ["dt-extensions-sdk[cli]"]},
+)

dynatrace_extension/cli/main.py

@@ -4,7 +4,6 @@ import stat
 import subprocess
 import sys
 from pathlib import Path
-from typing import List, Optional
 
 import typer
 from dtcli.server_api import upload as dt_cli_upload  # type: ignore
@@ -91,17 +90,17 @@ def build(
         "-k",
         help="Path to the dev fused key-certificate",
     ),
-    target_directory: Optional[Path] = typer.Option(None, "--target-directory", "-t"),
-    extra_platforms: Optional[list[str]] = typer.Option(
+    target_directory: Path | None = typer.Option(None, "--target-directory", "-t"),
+    extra_platforms: list[str] | None = typer.Option(
         None, "--extra-platform", "-e", help="Download wheels for an extra platform"
     ),
-    extra_index_url: Optional[str] = typer.Option(
+    extra_index_url: str | None = typer.Option(
         None, "--extra-index-url", "-i", help="Extra index url to use when downloading dependencies"
     ),
-    find_links: Optional[str] = typer.Option(
+    find_links: str | None = typer.Option(
         None, "--find-links", "-f", help="Extra index url to use when downloading dependencies"
     ),
-    only_extra_platforms: Optional[bool] = typer.Option(
+    only_extra_platforms: bool | None = typer.Option(
         False,
         "--only-extra-platforms",
         "-o",
@@ -163,7 +162,8 @@ def assemble(
 
     # Checks that the module name is valid and exists in the filesystem
     module_folder = Path(extension_dir) / extension_yaml.python.runtime.module
-    if not module_folder.exists():
+    src_module_folder = Path("src") / module_folder
+    if not module_folder.exists() and not src_module_folder.exists():
         msg = f"Extension module folder {module_folder} not found"
         raise FileNotFoundError(msg)
 
@@ -187,16 +187,16 @@ def assemble(
 @app.command(help="Downloads the dependencies of the extension to the lib folder")
 def wheel(
     extension_dir: Path = typer.Argument(".", help="Path to the python extension"),
-    extra_platforms: Optional[list[str]] = typer.Option(
+    extra_platforms: list[str] | None = typer.Option(
         None, "--extra-platform", "-e", help="Download wheels for an extra platform"
     ),
-    extra_index_url: Optional[str] = typer.Option(
+    extra_index_url: str | None = typer.Option(
         None, "--extra-index-url", "-i", help="Extra index url to use when downloading dependencies"
     ),
-    find_links: Optional[str] = typer.Option(
+    find_links: str | None = typer.Option(
         None, "--find-links", "-f", help="Extra index url to use when downloading dependencies"
     ),
-    only_extra_platforms: Optional[bool] = typer.Option(
+    only_extra_platforms: bool | None = typer.Option(
         False,
         "--only-extra-platforms",
         "-o",
@@ -425,9 +425,57 @@ def create(extension_name: str, output: Path = typer.Option(None, "--output", "-
     console.print(f"Extension created at {extension_path}", style="bold green")
 
 
-def run_process(
-    command: List[str], cwd: Optional[Path] = None, env: Optional[dict] = None, print_message: Optional[str] = None
+@app.command(
+    "format",
+    help="Runs ruff format on the extension code",
+)
+def fmt(extension_dir: Path = typer.Argument(".", help="Path to the python extension")):
+    """
+    Runs ruff format on the extension code
+
+    :param extension_dir: The directory of the extension, by default this is the current directory
+    """
+    run_process(["ruff", "format", str(extension_dir.resolve())])
+
+
+@app.command(help="Runs ruff check on the extension code")
+def lint(
+    extension_dir: Path = typer.Argument(".", help="Path to the python extension"),
+    fix: bool = typer.Option(False, "--fix", "-f", help="Fix linting issues"),
 ):
+    """
+    Runs ruff lint on the extension code
+
+    :param extension_dir: The directory of the extension, by default this is the current directory
+    :param fix: If true, ask ruff to also fix the linting issues
+    """
+    command = ["ruff", "check", "--exit-zero"]
+    if fix:
+        command.append("--fix")
+    command.append(str(extension_dir.resolve()))
+    run_process(command)
+
+
+@app.command(help="Adds ruff rules if they don't exist already")
+def ruff_init(extension_dir: Path = typer.Argument(".", help="Path to the python extension")):
+    """
+    Adds ruff rules if they don't exist already
+
+    :param extension_dir: The directory of the extension, by default this is the current directory
+    """
+
+    if (extension_dir / "ruff.toml").exists():
+        console.print(f"ruff.toml already exists in {extension_dir.resolve()}, skipping", style="bold yellow")
+        return
+    else:
+        # create\extension_template\ruff.toml.template -> extension\ruff.toml
+        ruff_template = Path(__file__).parent / "create" / "extension_template" / "ruff.toml.template"
+        ruff_file = extension_dir / "ruff.toml"
+        shutil.copy(ruff_template, ruff_file)
+        console.print(f"Added ruff.toml to {extension_dir.resolve()}", style="bold green")
+
+
+def run_process(command: list[str], cwd: Path | None = None, env: dict | None = None, print_message: str | None = None):
     friendly_command = " ".join(command)
     if print_message is not None:
         console.print(print_message, style="cyan")

dynatrace_extension/sdk/activation.py

@@ -3,7 +3,6 @@
 # SPDX-License-Identifier: MIT
 
 from enum import Enum
-from typing import List
 
 
 class ActivationType(Enum):
@@ -17,7 +16,7 @@ class ActivationConfig(dict):
         self.version: str = self._activation_context_json.get("version", "")
         self.enabled: bool = self._activation_context_json.get("enabled", True)
         self.description: str = self._activation_context_json.get("description", "")
-        self.feature_sets: List[str] = self._activation_context_json.get("featureSets", [])
+        self.feature_sets: list[str] = self._activation_context_json.get("featureSets", [])
         self.type: ActivationType = ActivationType.REMOTE if self.remote else ActivationType.LOCAL
         super().__init__()
 

dynatrace_extension/sdk/callback.py

@@ -4,9 +4,9 @@
 
 import logging
 import random
+from collections.abc import Callable
 from datetime import datetime, timedelta
 from timeit import default_timer as timer
-from typing import Callable, Dict, Optional, Tuple
 
 from .activation import ActivationType
 from .communication import MultiStatus, Status, StatusValue
@@ -18,10 +18,10 @@ class WrappedCallback:
         interval: timedelta,
         callback: Callable,
         logger: logging.Logger,
-        args: Optional[Tuple] = None,
-        kwargs: Optional[Dict] = None,
+        args: tuple | None = None,
+        kwargs: dict | None = None,
         running_in_sim=False,
-        activation_type: Optional[ActivationType] = None,
+        activation_type: ActivationType | None = None,
     ):
         self.callback: Callable = callback
         if args is None:

dynatrace_extension/sdk/communication.py

@@ -8,16 +8,17 @@ import json
 import logging
 import sys
 from abc import ABC, abstractmethod
+from collections.abc import Generator, Sequence
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
-from typing import Any, Generator, List, Sequence, TypeVar
+from typing import Any, TypeVar
 
 from .vendor.mureq.mureq import HTTPException, Response, request
 
 CONTENT_TYPE_JSON = "application/json;charset=utf-8"
 CONTENT_TYPE_PLAIN = "text/plain;charset=utf-8"
-COUNT_METRIC_ITEMS_DICT = TypeVar("COUNT_METRIC_ITEMS_DICT", str, List[str])
+COUNT_METRIC_ITEMS_DICT = TypeVar("COUNT_METRIC_ITEMS_DICT", str, list[str])
 
 # TODO - I believe these can be adjusted via RuntimeConfig, they can't be constants
 MAX_MINT_LINES_PER_REQUEST = 1000
@@ -60,7 +61,6 @@ class Status:
 
 
 class MultiStatus:
-
     def __init__(self):
         self.statuses = []
 
@@ -352,7 +352,6 @@ class DebugClient(CommunicationClient):
         local_ingest_port: int = 14499,
         print_metrics: bool = True,
     ):
-
         self.secrets = {}
         if secrets_path and Path(secrets_path).exists():
             with open(secrets_path) as f:

dynatrace_extension/sdk/extension.py

@@ -9,13 +9,14 @@ import sys
 import threading
 import time
 from argparse import ArgumentParser
+from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timedelta, timezone
 from enum import Enum
 from itertools import chain
 from pathlib import Path
 from threading import Lock, RLock, active_count
-from typing import Any, Callable, ClassVar, Dict, List, NamedTuple, Optional, Union
+from typing import Any, ClassVar, NamedTuple
 
 from .activation import ActivationConfig, ActivationType
 from .callback import WrappedCallback
@@ -99,7 +100,7 @@ class CountMetricRegistrationEntry(NamedTuple):
     dimensions_list: list[str]
 
     @staticmethod
-    def make_list(metric_key: str, dimensions_list: List[str]):
+    def make_list(metric_key: str, dimensions_list: list[str]):
         """Build an entry that uses defined list of dimensions for aggregation.
 
         Args:
@@ -135,7 +136,7 @@ class CountMetricRegistrationEntry(NamedTuple):
             return result
 
 
-def _add_sfm_metric(metric: Metric, sfm_metrics: Optional[List[Metric]] = None):
+def _add_sfm_metric(metric: Metric, sfm_metrics: list[Metric] | None = None):
     if sfm_metrics is None:
         sfm_metrics = []
     metric.validate()
@@ -152,7 +153,7 @@ class Extension:
     _instance: ClassVar = None
     schedule_decorators: ClassVar = []
 
-    def __new__(cls, *args, **kwargs):  # noqa: ARG003
+    def __new__(cls, *args, **kwargs):  # noqa: ARG004
         if Extension._instance is None:
             Extension._instance = super(__class__, cls).__new__(cls)
         return Extension._instance
@@ -194,24 +195,24 @@ class Extension:
         self._cluster_time_diff: int = 0
 
         # Optional callback to be invoked during the fastcheck
-        self._fast_check_callback: Optional[Callable[[ActivationConfig, str], Status]] = None
+        self._fast_check_callback: Callable[[ActivationConfig, str], Status] | None = None
 
         # List of all scheduled callbacks we must run
-        self._scheduled_callbacks: List[WrappedCallback] = []
-        self._scheduled_callbacks_before_run: List[WrappedCallback] = []
+        self._scheduled_callbacks: list[WrappedCallback] = []
+        self._scheduled_callbacks_before_run: list[WrappedCallback] = []
 
         # Internal callbacks results, used to report statuses
-        self._internal_callbacks_results: Dict[str, Status] = {}
+        self._internal_callbacks_results: dict[str, Status] = {}
         self._internal_callbacks_results_lock: Lock = Lock()
 
         # Running callbacks, used to get the callback info when reporting metrics
-        self._running_callbacks: Dict[int, WrappedCallback] = {}
+        self._running_callbacks: dict[int, WrappedCallback] = {}
         self._running_callbacks_lock: Lock = Lock()
 
         self._scheduler = sched.scheduler(time.time, time.sleep)
 
         # Timestamps for scheduling of internal callbacks
-        self._next_internal_callbacks_timestamps: Dict[str, datetime] = {
+        self._next_internal_callbacks_timestamps: dict[str, datetime] = {
             "timediff": datetime.now() + TIME_DIFF_INTERVAL,
             "heartbeat": datetime.now() + HEARTBEAT_INTERVAL,
             "metrics": datetime.now() + METRIC_SENDING_INTERVAL,
@@ -226,15 +227,15 @@ class Extension:
 
         # Extension metrics
         self._metrics_lock = RLock()
-        self._metrics: List[str] = []
+        self._metrics: list[str] = []
 
         # Extension logs
         self._logs_lock = RLock()
-        self._logs: List[dict] = []
+        self._logs: list[dict] = []
 
         # Self monitoring metrics
         self._sfm_metrics_lock = Lock()
-        self._callbackSfmReport: Dict[str, WrappedCallback] = {}
+        self._callbackSfmReport: dict[str, WrappedCallback] = {}
 
         # Count metric delta signals
         self._delta_signal_buffer: set[str] = set()
@@ -342,9 +343,9 @@ class Extension:
     def schedule(
         self,
         callback: Callable,
-        interval: Union[timedelta, int],
-        args: Optional[tuple] = None,
-        activation_type: Optional[ActivationType] = None,
+        interval: timedelta | int,
+        args: tuple | None = None,
+        activation_type: ActivationType | None = None,
     ) -> None:
         """Schedule a method to be executed periodically.
 
@@ -455,10 +456,11 @@ class Extension:
     def report_metric(
         self,
         key: str,
-        value: Union[float, str, int, SummaryStat],
-        dimensions: Optional[Dict[str, str]] = None,
-        techrule: Optional[str] = None,
-        timestamp: Optional[datetime] = None,
+        value: float | str | int | SummaryStat,
+        dimensions: dict[str, str] | None = None,
+        device_address: str | None = None,
+        techrule: str | None = None,
+        timestamp: datetime | None = None,
         metric_type: MetricType = MetricType.GAUGE,
     ) -> None:
         """Report a metric.
@@ -472,6 +474,7 @@ class Extension:
             key: The metric key, must follow the MINT specification
             value: The metric value, can be a simple value or a SummaryStat
             dimensions: A dictionary of dimensions
+            device_address: The address of a monitored device/endpoint which produced the metric
             techrule: The technology rule string set by self.techrule setter.
             timestamp: The timestamp of the metric, defaults to the current time
             metric_type: The type of the metric, defaults to MetricType.GAUGE
@@ -483,6 +486,12 @@ class Extension:
             if "dt.techrule.id" not in dimensions:
                 dimensions["dt.techrule.id"] = techrule
 
+        if device_address:
+            if not dimensions:
+                dimensions = {}
+            if "device.address" not in dimensions:
+                dimensions["device.address"] = device_address
+
         if metric_type == MetricType.COUNT and timestamp is None:
             # We must report a timestamp for count metrics
             timestamp = datetime.now()
@@ -490,7 +499,7 @@ class Extension:
         metric = Metric(key=key, value=value, dimensions=dimensions, metric_type=metric_type, timestamp=timestamp)
         self._add_metric(metric)
 
-    def report_mint_lines(self, lines: List[str]) -> None:
+    def report_mint_lines(self, lines: list[str]) -> None:
         """Report mint lines using the MINT protocol
 
         Examples:
@@ -507,9 +516,9 @@ class Extension:
         self,
         title: str,
         description: str,
-        properties: Optional[dict] = None,
-        timestamp: Optional[datetime] = None,
-        severity: Union[Severity, str] = Severity.INFO,
+        properties: dict | None = None,
+        timestamp: datetime | None = None,
+        severity: Severity | str = Severity.INFO,
         send_immediately: bool = False,
     ) -> None:
         """Report an event using log ingest.
@@ -543,11 +552,11 @@ class Extension:
         self,
         event_type: DtEventType,
         title: str,
-        start_time: Optional[int] = None,
-        end_time: Optional[int] = None,
-        timeout: Optional[int] = None,
-        entity_selector: Optional[str] = None,
-        properties: Optional[dict[str, str]] = None,
+        start_time: int | None = None,
+        end_time: int | None = None,
+        timeout: int | None = None,
+        entity_selector: str | None = None,
+        properties: dict[str, str] | None = None,
     ) -> None:
         """
         Reports an event using the v2 event ingest API.
@@ -567,7 +576,7 @@ class Extension:
             entity_selector: The entity selector, if not set, the event is associated with environment entity (optional)
             properties: A map of event properties (optional)
         """
-        event: Dict[str, Any] = {"eventType": event_type, "title": title}
+        event: dict[str, Any] = {"eventType": event_type, "title": title}
         if start_time:
             event["startTime"] = start_time
         if end_time:
@@ -654,7 +663,7 @@ class Extension:
         """
         self._send_events(log_event, send_immediately=send_immediately)
 
-    def report_log_events(self, log_events: List[dict], send_immediately: bool = False):
+    def report_log_events(self, log_events: list[dict], send_immediately: bool = False):
         """Report a list of custom log events using log ingest.
 
         Args:
@@ -663,7 +672,7 @@ class Extension:
         """
         self._send_events(log_events, send_immediately=send_immediately)
 
-    def report_log_lines(self, log_lines: List[Union[str, bytes]], send_immediately: bool = False):
+    def report_log_lines(self, log_lines: list[str | bytes], send_immediately: bool = False):
         """Report a list of log lines using log ingest
 
         Args:
@@ -877,13 +886,13 @@ class Extension:
                     api_logger.info(f"Sent {number_of_metrics} metric lines to EEC: {responses}")
                     self._metrics = []
 
-    def _prepare_sfm_metrics(self) -> List[str]:
+    def _prepare_sfm_metrics(self) -> list[str]:
         """Prepare self monitoring metrics.
 
         Builds the list of mint metric lines to send as self monitoring metrics.
         """
 
-        sfm_metrics: List[Metric] = []
+        sfm_metrics: list[Metric] = []
         sfm_dimensions = {"dt.extension.config.id": self.monitoring_config_id}
         _add_sfm_metric(
             SfmMetric("threads", active_count(), sfm_dimensions, client_facing=True, metric_type=MetricType.DELTA),
@@ -1039,11 +1048,11 @@ class Extension:
         with self._metrics_lock:
             self._metrics.append(metric.to_mint_line())
 
-    def _add_mint_lines(self, lines: List[str]):
+    def _add_mint_lines(self, lines: list[str]):
         with self._metrics_lock:
             self._metrics.extend(lines)
 
-    def _send_events_internal(self, events: Union[dict, List[dict]]):
+    def _send_events_internal(self, events: dict | list[dict]):
         try:
             responses = self._client.send_events(events, self.log_event_enrichment)
 
@@ -1060,7 +1069,7 @@ class Extension:
             with self._internal_callbacks_results_lock:
                 self._internal_callbacks_results[self._send_events.__name__] = Status(StatusValue.GENERIC_ERROR, str(e))
 
-    def _send_events(self, events: Union[dict, List[dict]], send_immediately: bool = False):
+    def _send_events(self, events: dict | list[dict], send_immediately: bool = False):
         if send_immediately:
             self._internal_executor.submit(self._send_events_internal, events)
             return

dynatrace_extension/sdk/helper.py

@@ -2,8 +2,8 @@
 #
 # SPDX-License-Identifier: MIT
 
+from collections.abc import Callable
 from datetime import datetime, timedelta
-from typing import Callable, Dict, List, Optional, Union
 
 from .activation import ActivationConfig, ActivationType
 from .communication import Status
@@ -20,10 +20,10 @@ class _HelperExtension(Extension):
 
 def report_metric(
     key: str,
-    value: Union[float, str, int, SummaryStat],
-    dimensions: Optional[Dict[str, str]] = None,
-    techrule: Optional[str] = None,
-    timestamp: Optional[datetime] = None,
+    value: float | str | int | SummaryStat,
+    dimensions: dict[str, str] | None = None,
+    techrule: str | None = None,
+    timestamp: datetime | None = None,
     metric_type: MetricType = MetricType.GAUGE,
 ) -> None:
     """Reports a metric using the MINT protocol
@@ -37,10 +37,10 @@ def report_metric(
     :param timestamp: The timestamp of the metric, defaults to the current time
     :param metric_type: The type of the metric, defaults to MetricType.GAUGE
     """
-    _HelperExtension().report_metric(key, value, dimensions, techrule, timestamp, metric_type)
+    _HelperExtension().report_metric(key, value, dimensions, techrule, timestamp, metric_type)  # type: ignore
 
 
-def report_mint_lines(lines: List[str]) -> None:
+def report_mint_lines(lines: list[str]) -> None:
     """Reports mint lines using the MINT protocol.
     These lines are not validated before being sent.
 
@@ -52,11 +52,11 @@ def report_mint_lines(lines: List[str]) -> None:
 def report_dt_event(
     event_type: DtEventType,
     title: str,
-    start_time: Optional[int] = None,
-    end_time: Optional[int] = None,
-    timeout: Optional[int] = None,
-    entity_selector: Optional[str] = None,
-    properties: Optional[dict[str, str]] = None,
+    start_time: int | None = None,
+    end_time: int | None = None,
+    timeout: int | None = None,
+    entity_selector: str | None = None,
+    properties: dict[str, str] | None = None,
 ) -> None:
     """
     Reports a custom event v2 using event ingest
@@ -85,9 +85,9 @@ def report_dt_event_dict(event: dict):
 
 def schedule(
     callback: Callable,
-    interval: Union[timedelta, int],
-    args: Optional[tuple] = None,
-    activation_type: Optional[ActivationType] = None,
+    interval: timedelta | int,
+    args: tuple | None = None,
+    activation_type: ActivationType | None = None,
 ) -> None:
     """Schedules a callback to be called periodically
 
@@ -101,7 +101,7 @@ def schedule(
 
 
 def schedule_function(
-    interval: Union[timedelta, int], args: Optional[tuple] = None, activation_type: Optional[ActivationType] = None
+    interval: timedelta | int, args: tuple | None = None, activation_type: ActivationType | None = None
 ):
     def decorator(function):
         schedule(function, interval, args=args, activation_type=activation_type)
@@ -110,7 +110,7 @@ def schedule_function(
 
 
 def schedule_method(
-    interval: Union[timedelta, int], args: Optional[tuple] = None, activation_type: Optional[ActivationType] = None
+    interval: timedelta | int, args: tuple | None = None, activation_type: ActivationType | None = None
 ):
     def decorator(function):
         Extension.schedule_decorators.append((function, interval, args, activation_type))
@@ -121,9 +121,9 @@ def schedule_method(
 def report_event(
     title: str,
     description: str,
-    properties: Optional[dict] = None,
-    timestamp: Optional[datetime] = None,
-    severity: Union[Severity, str] = Severity.INFO,
+    properties: dict | None = None,
+    timestamp: datetime | None = None,
+    severity: Severity | str = Severity.INFO,
 ) -> None:
     """Reports an event using the MINT protocol
 
@@ -144,7 +144,7 @@ def report_log_event(log_event: dict):
     _HelperExtension().report_log_event(log_event)
 
 
-def report_log_events(log_events: List[dict]):
+def report_log_events(log_events: list[dict]):
     """Reports a list of custom log events using log ingest
 
     :param log_events: The list of log events
@@ -152,7 +152,7 @@ def report_log_events(log_events: List[dict]):
     _HelperExtension().report_log_events(log_events)
 
 
-def report_log_lines(log_lines: List[Union[str, bytes]]):
+def report_log_lines(log_lines: list[str | bytes]):
     """Reports a list of log lines using log ingest
 
     :param log_lines: The list of log lines

dynatrace_extension/sdk/metric.py

@@ -4,7 +4,6 @@
 
 from datetime import datetime
 from enum import Enum
-from typing import Dict, Optional, Union
 
 # https://bitbucket.lab.dynatrace.org/projects/ONE/repos/schemaless-metrics-spec/browse/limits.md
 LIMIT_DIMENSIONS_COUNT = 50
@@ -41,18 +40,18 @@ class Metric:
     def __init__(
         self,
         key: str,
-        value: Union[float, int, str, SummaryStat],
-        dimensions: Optional[Dict[str, str]] = None,
+        value: float | int | str | SummaryStat,
+        dimensions: dict[str, str] | None = None,
         metric_type: MetricType = MetricType.GAUGE,
-        timestamp: Optional[datetime] = None,
+        timestamp: datetime | None = None,
     ):
         self.key: str = key
-        self.value: Union[float, int, str, SummaryStat] = value
+        self.value: float | int | str | SummaryStat = value
         if dimensions is None:
             dimensions = {}
-        self.dimensions: Dict[str, str] = dimensions
+        self.dimensions: dict[str, str] = dimensions
         self.metric_type: MetricType = metric_type
-        self.timestamp: Optional[datetime] = timestamp
+        self.timestamp: datetime | None = timestamp
 
     def __hash__(self):
         return hash(self._key_and_dimensions())
@@ -103,10 +102,10 @@ class SfmMetric(Metric):
     def __init__(
         self,
         key: str,
-        value: Union[float, int, str, SummaryStat],
-        dimensions: Optional[Dict[str, str]] = None,
+        value: float | int | str | SummaryStat,
+        dimensions: dict[str, str] | None = None,
         metric_type: MetricType = MetricType.GAUGE,
-        timestamp: Optional[datetime] = None,
+        timestamp: datetime | None = None,
         client_facing: bool = False,
     ):
         key = create_sfm_metric_key(key, client_facing)

dynatrace_extension/sdk/runtime.py

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: MIT
 
 import logging
-from typing import ClassVar, List, NamedTuple
+from typing import ClassVar, NamedTuple
 
 
 class DefaultLogLevel(NamedTuple):
@@ -25,7 +25,7 @@ class RuntimeProperties:
         self.userconfig: str = json_response.get("userconfig", "")
         self.debugmode: bool = json_response.get("debugmode", "0") == "1"
         self.runtime: dict = json_response.get("runtime", {})
-        self.tasks: List[str] = json_response.get("tasks", [])
+        self.tasks: list[str] = json_response.get("tasks", [])
 
     @classmethod
     def set_default_log_level(cls, value: str):

dynatrace_extension/sdk/snapshot.py

@@ -14,12 +14,14 @@ PREFIX_PGI = "PROCESS_GROUP_INSTANCE"
 class EntryProperties:
     technologies: list[str]
     pg_technologies: list[str]
+    extra_properties: dict[str, str]
 
     @staticmethod
-    def from_json(json_data: dict) -> EntryProperties:
+    def from_json(json_data: dict[str, str]) -> EntryProperties:
         technologies = json_data.get("Technologies", "").split(",")
         pg_technologies = json_data.get("pgTechnologies", "").split(",")
-        return EntryProperties(technologies, pg_technologies)
+        extra_properties = {k: v for k, v in json_data.items() if k not in ["Technologies", "pgTechnologies"]}
+        return EntryProperties(technologies, pg_technologies, extra_properties)
 
 
 @dataclass
@@ -111,15 +113,23 @@ class Entry:
         processes = [Process.from_json(p) for p in json_data.get("processes", [])]
 
         # The structure here was never thought out, so we have to check for both keys and merge them into one object
-        properties_list = json_data.get("properties", [])
-        technologies = [p for p in properties_list if "Technologies" in p]
-        if technologies:
-            technologies = technologies[0]["Technologies"].split(",")
-
-        pg_technologies = [p for p in properties_list if "pgTechnologies" in p]
-        if pg_technologies:
-            pg_technologies = pg_technologies[0]["pgTechnologies"].split(",")
-        properties = EntryProperties(technologies or [], pg_technologies or [])
+        properties_list: list[dict[str, str]] = json_data.get("properties", [])
+        technologies = []
+        pg_technologies = []
+        # There may be other useful properties included such as: mssql_instance_name.
+        extra_properties = {}
+
+        for prop in properties_list:
+            for key, value in prop.items():
+                match key:
+                    case "Technologies":
+                        technologies.extend(value.split(","))
+                    case "pgTechnologies":
+                        pg_technologies.extend(value.split(","))
+                    case _:
+                        extra_properties[key] = value
+
+        properties = EntryProperties(technologies, pg_technologies, extra_properties)
 
         return Entry(group_id, node_id, group_instance_id, process_type, group_name, processes, properties)