datadog-checks-base 37.7.0__py2.py3-none-any.whl → 37.8.0__py2.py3-none-any.whl

datadog_checks/base/checks/win/wmi/base.py

@@ -0,0 +1,390 @@
+# (C) Datadog, Inc. 2025-present
+# All rights reserved
+# Licensed under a 3-clause BSD style license (see LICENSE)
+from typing import Any, Dict, List, Optional, Tuple  # noqa: F401
+
+from ... import AgentCheck
+from .sampler import WMISampler
+from .types import TagQuery, WMIFilter, WMIMetric, WMIObject, WMIProperties  # noqa: F401
+
+
+class InvalidWMIQuery(Exception):
+    """
+    Invalid WMI Query.
+    """
+
+    pass
+
+
+class MissingTagBy(Exception):
+    """
+    WMI query returned multiple rows but no `tag_by` value was given.
+    """
+
+    pass
+
+
+class TagQueryUniquenessFailure(Exception):
+    """
+    'Tagging query' did not return or returned multiple results.
+    """
+
+    pass
+
+
+class WinWMICheck(AgentCheck):
+    """
+    WMI check.
+
+    Windows only.
+    """
+
+    def __init__(self, *args, **kwargs):  # To support optional agentConfig
+        # type: (*Any, **Any) -> None
+        super(WinWMICheck, self).__init__(*args, **kwargs)
+
+        # Connection information
+        self.host = self.instance.get('host', "localhost")  # type: str
+        self.namespace = self.instance.get('namespace', "root\\cimv2")  # type: str
+        self.provider = self.instance.get('provider')  # type: Optional[int]
+        self.username = self.instance.get('username', "")  # type: str
+        self.password = self.instance.get('password', "")  # type: str
+
+        # WMI instance
+        self.wmi_class = self.instance.get('class', '')  # type: str
+
+        self._wmi_sampler = None  # type: Optional[WMISampler]
+        self._wmi_props = None  # type: Optional[WMIProperties]
+
+    def _format_tag_query(self, sampler, wmi_obj, tag_query):
+        # type: (WMISampler, WMIObject, TagQuery) -> Tuple[str, str, List[Dict]]
+        """
+        Format `tag_query` or raise on incorrect parameters.
+        """
+        try:
+            link_source_property = int(wmi_obj[tag_query[0]])
+            target_class = tag_query[1]
+            link_target_class_property = tag_query[2]
+            target_property = tag_query[3]
+        except IndexError:
+            self.log.error(
+                u"Wrong `tag_queries` parameter format. " "Please refer to the configuration file for more information."
+            )
+            raise
+        except TypeError:
+            wmi_property = tag_query[0]
+            wmi_class = sampler.class_name
+            self.log.error(
+                u"Incorrect 'link source property' in `tag_queries` parameter: `%s` is not a property of `%s`",
+                wmi_property,
+                wmi_class,
+            )
+            raise
+
+        return target_class, target_property, [{link_target_class_property: link_source_property}]
+
+    def _raise_on_invalid_tag_query_result(self, sampler, wmi_obj, tag_query):
+        # type: (WMISampler, WMIObject, TagQuery) -> None
+        target_property = sampler.property_names[0]
+        target_class = sampler.class_name
+
+        if len(sampler) != 1:
+            message = "no result was returned"
+            if len(sampler):
+                message = "multiple results returned (one expected)"
+
+            self.log.warning(
+                u"Failed to extract a tag from `tag_queries` parameter: %s. wmi_object=%s - query=%s",
+                message,
+                wmi_obj,
+                tag_query,
+            )
+            raise TagQueryUniquenessFailure
+
+        if sampler[0][target_property] is None:
+            self.log.error(
+                u"Incorrect 'target property' in `tag_queries` parameter: `%s` is empty or is not a property of `%s`",
+                target_property,
+                target_class,
+            )
+            raise TypeError
+
+    def _get_tag_query_tag(self, sampler, wmi_obj, tag_query):
+        # type: (WMISampler, WMIObject, TagQuery) -> str
+        """
+        Design a query based on the given WMIObject to extract a tag.
+
+        Returns: tag or TagQueryUniquenessFailure exception.
+        """
+        self.log.debug(u"`tag_queries` parameter found. wmi_object=%s - query=%s", wmi_obj, tag_query)
+
+        # Extract query information
+        target_class, target_property, filters = self._format_tag_query(sampler, wmi_obj, tag_query)
+
+        # Create a specific sampler
+        with WMISampler(
+            self.log, target_class, [target_property], filters=filters, **sampler.connection
+        ) as tag_query_sampler:
+            tag_query_sampler.sample()
+
+            # Extract tag
+            self._raise_on_invalid_tag_query_result(tag_query_sampler, wmi_obj, tag_query)
+
+            link_value = str(tag_query_sampler[0][target_property]).lower()
+
+        tag = "{tag_name}:{tag_value}".format(tag_name=target_property.lower(), tag_value="_".join(link_value.split()))
+
+        self.log.debug(u"Extracted `tag_queries` tag: '%s'", tag)
+        return tag
+
+    def _extract_metrics(self, wmi_sampler, tag_by, tag_queries, constant_tags):
+        # type: (WMISampler, str, List[List[str]], List[str]) -> List[WMIMetric]
+        """
+        Extract and tag metrics from the WMISampler.
+
+        Raise when multiple WMIObject were returned by the sampler with no `tag_by` specified.
+
+        Returns: List of WMIMetric
+        ```
+        [
+            WMIMetric("freemegabytes", 19742, ["name:_total"]),
+            WMIMetric("avgdiskbytesperwrite", 1536, ["name:c:"]),
+        ]
+        ```
+        """
+        if len(wmi_sampler) > 1 and not tag_by:
+            raise MissingTagBy(
+                u"WMI query returned multiple rows but no `tag_by` value was given."
+                " class={wmi_class} - properties={wmi_properties} - filters={filters}".format(
+                    wmi_class=wmi_sampler.class_name,
+                    wmi_properties=wmi_sampler.property_names,
+                    filters=wmi_sampler.filters,
+                )
+            )
+
+        extracted_metrics = []
+        tag_by = tag_by.lower()
+
+        for wmi_obj in wmi_sampler:
+            tags = list(constant_tags) if constant_tags else []
+
+            # Tag with `tag_queries` parameter
+            for query in tag_queries:
+                try:
+                    tags.append(self._get_tag_query_tag(wmi_sampler, wmi_obj, query))
+                except TagQueryUniquenessFailure:
+                    continue
+
+            for wmi_property, wmi_value in wmi_obj.items():
+                # skips any property not in arguments since SWbemServices.ExecQuery will return key prop properties
+                # https://msdn.microsoft.com/en-us/library/aa393866(v=vs.85).aspx
+
+                # skip wmi_property "foo,bar"; there will be a separate wmi_property for each "foo" and "bar"
+                if ',' in wmi_property:
+                    continue
+
+                normalized_wmi_property = wmi_property.lower()
+                for s in wmi_sampler.property_names:
+                    if normalized_wmi_property in s.lower():
+                        # wmi_property: "foo" should be found in property_names ["foo,bar", "name"]
+                        break
+                else:
+                    continue
+                # Tag with `tag_by` parameter
+                for t in tag_by.split(','):
+                    t = t.strip()
+                    if wmi_property == t:
+                        tag_value = str(wmi_value).lower()
+                        if tag_queries and tag_value.find("#") > 0:
+                            tag_value = tag_value[: tag_value.find("#")]
+
+                        tags.append("{name}:{value}".format(name=t, value=tag_value))
+                        continue
+
+                # No metric extraction on 'Name' and properties in tag_by
+                if wmi_property == 'name' or normalized_wmi_property in tag_by.lower():
+                    continue
+
+                try:
+                    extracted_metrics.append(WMIMetric(wmi_property, float(wmi_value), tags))
+                except ValueError:
+                    self.log.warning(
+                        u"When extracting metrics with WMI, found a non digit value for property '%s'.", wmi_property
+                    )
+                    continue
+                except TypeError:
+                    self.log.warning(u"When extracting metrics with WMI, found a missing property '%s'", wmi_property)
+                    continue
+        return extracted_metrics
+
+    def _submit_metrics(self, metrics, metric_name_and_type_by_property):
+        # type: (List[WMIMetric], Dict[str, Tuple[str, str]]) -> None
+        """
+        Resolve metric names and types and submit it.
+        """
+        for metric in metrics:
+            if (
+                metric.name not in metric_name_and_type_by_property
+                and metric.name.lower() not in metric_name_and_type_by_property
+            ):
+                # Only report the metrics that were specified in the configuration
+                # Ignore added properties like 'Timestamp_Sys100NS', `Frequency_Sys100NS`, etc ...
+                continue
+
+            if metric_name_and_type_by_property.get(metric.name):
+                metric_name, metric_type = metric_name_and_type_by_property[metric.name]
+            elif metric_name_and_type_by_property.get(metric.name.lower()):
+                metric_name, metric_type = metric_name_and_type_by_property[metric.name.lower()]
+            else:
+                continue
+
+            try:
+                func = getattr(self, metric_type.lower())
+            except AttributeError:
+                raise Exception(u"Invalid metric type: {0}".format(metric_type))
+
+            func(metric_name, metric.value, metric.tags)
+
+    def _get_instance_key(self, host, namespace, wmi_class, other=None):
+        # type: (str, str, str, Any) -> str
+        """
+        Return an index key for a given instance. Useful for caching.
+        """
+        if other:
+            return "{host}:{namespace}:{wmi_class}-{other}".format(
+                host=host, namespace=namespace, wmi_class=wmi_class, other=other
+            )
+        return "{host}:{namespace}:{wmi_class}".format(host=host, namespace=namespace, wmi_class=wmi_class)
+
+    def get_running_wmi_sampler(self, properties, filters, **kwargs):
+        # type: (List[str], List[Dict[str, WMIFilter]], **Any) -> WMISampler
+        tag_by = kwargs.pop('tag_by', "")
+        return self._get_running_wmi_sampler(
+            instance_key=None,
+            wmi_class=self.wmi_class,
+            properties=properties,
+            filters=filters,
+            host=self.host,
+            namespace=self.namespace,
+            provider=self.provider,
+            username=self.username,
+            password=self.password,
+            tag_by=tag_by,
+            **kwargs
+        )
+
+    def _get_running_wmi_sampler(self, instance_key, wmi_class, properties, tag_by="", **kwargs):
+        # type: (Any, str, List[str], str, Any) -> WMISampler
+        """
+        Return a running WMISampler for the given (class, properties).
+
+        If no matching WMISampler is running yet, start one and cache it.
+        """
+        if self._wmi_sampler is None:
+            property_list = list(properties) + [tag_by] if tag_by else list(properties)
+            self._wmi_sampler = WMISampler(self.log, wmi_class, property_list, **kwargs)
+            self._wmi_sampler.start()
+
+        return self._wmi_sampler
+
+    def _get_wmi_properties(self, instance_key, metrics, tag_queries):
+        # type: (Any, List[List[str]], List[List[str]]) -> WMIProperties
+        """
+        Create and cache a (metric name, metric type) by WMI property map and a property list.
+        """
+        if not self._wmi_props:
+            metric_name_by_property = dict(  # noqa: C402
+                (wmi_property.lower(), (metric_name, metric_type)) for wmi_property, metric_name, metric_type in metrics
+            )  # type: Dict[str, Tuple[str, str]]
+            properties = map(lambda x: x[0], metrics + tag_queries)  # type: List[str]  # noqa: C417
+
+            self._wmi_props = (metric_name_by_property, properties)
+
+        return self._wmi_props
+
+
+def from_time(
+    year=None, month=None, day=None, hours=None, minutes=None, seconds=None, microseconds=None, timezone=None
+):
+    # type: (int, int, int, int, int, int, int, int) -> str
+    """Convenience wrapper to take a series of date/time elements and return a WMI time
+    of the form `yyyymmddHHMMSS.mmmmmm+UUU`. All elements may be int, string or
+    omitted altogether. If omitted, they will be replaced in the output string
+    by a series of stars of the appropriate length.
+    :param year: The year element of the date/time
+    :param month: The month element of the date/time
+    :param day: The day element of the date/time
+    :param hours: The hours element of the date/time
+    :param minutes: The minutes element of the date/time
+    :param seconds: The seconds element of the date/time
+    :param microseconds: The microseconds element of the date/time
+    :param timezone: The timezone element of the date/time
+    :returns: A WMI datetime string of the form: `yyyymmddHHMMSS.mmmmmm+UUU`
+    """
+
+    def str_or_stars(i, length):
+        # type: (Optional[int], int) -> str
+        if i is None:
+            return "*" * length
+        else:
+            return str(i).rjust(length, "0")
+
+    wmi_time = ""
+    wmi_time += str_or_stars(year, 4)
+    wmi_time += str_or_stars(month, 2)
+    wmi_time += str_or_stars(day, 2)
+    wmi_time += str_or_stars(hours, 2)
+    wmi_time += str_or_stars(minutes, 2)
+    wmi_time += str_or_stars(seconds, 2)
+    wmi_time += "."
+    wmi_time += str_or_stars(microseconds, 6)
+    if timezone is None:
+        wmi_time += "+"
+    else:
+        try:
+            int(timezone)
+        except ValueError:
+            wmi_time += "+"
+        else:
+            if timezone >= 0:
+                wmi_time += "+"
+            else:
+                wmi_time += "-"
+                timezone = abs(timezone)
+                wmi_time += str_or_stars(timezone, 3)
+
+    return wmi_time
+
+
+def to_time(wmi_time):
+    # type: (str) -> Tuple[Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], Optional[int], Optional[str]]
+    """Convenience wrapper to take a WMI datetime string of the form
+    yyyymmddHHMMSS.mmmmmm+UUU and return a 9-tuple containing the
+    individual elements, or None where string contains placeholder
+    stars.
+
+    :param wmi_time: The WMI datetime string in `yyyymmddHHMMSS.mmmmmm+UUU` format
+
+    :returns: A 9-tuple of (year, month, day, hours, minutes, seconds, microseconds, timezone)
+    """
+
+    def int_or_none(s, start, end):
+        # type: (str, int, int) -> Optional[int]
+        try:
+            return int(s[start:end])
+        except ValueError:
+            return None
+
+    year = int_or_none(wmi_time, 0, 4)
+    month = int_or_none(wmi_time, 4, 6)
+    day = int_or_none(wmi_time, 6, 8)
+    hours = int_or_none(wmi_time, 8, 10)
+    minutes = int_or_none(wmi_time, 10, 12)
+    seconds = int_or_none(wmi_time, 12, 14)
+    microseconds = int_or_none(wmi_time, 15, 21)
+    timezone = wmi_time[22:]  # type: Optional[str]
+
+    if timezone == "***":
+        timezone = None
+
+    return year, month, day, hours, minutes, seconds, microseconds, timezone

datadog_checks/base/log.py

@@ -1,18 +1,24 @@
 # (C) Datadog, Inc. 2018-present
 # All rights reserved
 # Licensed under a 3-clause BSD style license (see LICENSE)
+from __future__ import annotations
+
 import logging
 import sys
-import warnings
-from typing import Callable  # noqa: F401
+from typing import TYPE_CHECKING, Callable
 
-from urllib3.exceptions import InsecureRequestWarning
+import lazy_loader
 
 from datadog_checks.base.agent import datadog_agent
 
 from .utils.common import to_native_string
 from .utils.tracing import tracing_enabled
 
+if TYPE_CHECKING:
+    import inspect as _module_inspect
+
+inspect: _module_inspect = lazy_loader.load('inspect')
+
 # Arbitrary number less than 10 (DEBUG)
 TRACE_LEVEL = 7
 
@@ -33,8 +39,7 @@ class CheckLoggingAdapter(logging.LoggerAdapter):
         self.check = check
         self.check_id = self.check.check_id
 
-    def setup_sanitization(self, sanitize):
-        # type: (Callable[[str], str]) -> None
+    def setup_sanitization(self, sanitize: Callable[[str], str]) -> None:
         for handler in self.logger.handlers:
             if isinstance(handler, AgentLogHandler):
                 handler.setFormatter(SanitizationFormatter(handler.formatter, sanitize=sanitize))
@@ -158,9 +163,6 @@ def init_logging():
     rootLogger.addHandler(AgentLogHandler())
     rootLogger.setLevel(_get_py_loglevel(datadog_agent.get_config('log_level')))
 
-    # We log instead of emit warnings for unintentionally insecure HTTPS requests
-    warnings.simplefilter('ignore', InsecureRequestWarning)
-
     # `requests` (used in a lot of checks) imports `urllib3`, which logs a bunch of stuff at the info level
     # Therefore, pre emptively increase the default level of that logger to `WARN`
     urllib_logger = logging.getLogger("requests.packages.urllib3")

datadog_checks/base/stubs/datadog_agent.py

@@ -1,11 +1,10 @@
 # (C) Datadog, Inc. 2018-present
 # All rights reserved
 # Licensed under a 3-clause BSD style license (see LICENSE)
-import json
 import re
 from collections import defaultdict
 
-from datadog_checks.base.utils.serialization import from_json, to_json
+from datadog_checks.base.utils.format import json
 
 
 class DatadogAgentStub(object):
@@ -102,7 +101,7 @@ class DatadogAgentStub(object):
         return self._host_tags
 
     def _set_host_tags(self, tags_dict):
-        self._host_tags = json.dumps(tags_dict)
+        self._host_tags = json.encode(tags_dict)
 
     def _reset_host_tags(self):
         self._host_tags = "{}"
@@ -120,7 +119,7 @@ class DatadogAgentStub(object):
         self._metadata[(check_id, name)] = value
 
     def send_log(self, log_line, check_id):
-        self._sent_logs[check_id].append(from_json(log_line))
+        self._sent_logs[check_id].append(json.decode(log_line))
 
     def set_external_tags(self, external_tags):
         self._external_tags = external_tags
@@ -139,8 +138,8 @@ class DatadogAgentStub(object):
         if options:
             # Options provided is a JSON string because the Go stub requires it, whereas
             # the python stub does not for things such as testing.
-            if from_json(options).get('return_json_metadata', False):
-                return to_json({'query': re.sub(r'\s+', ' ', query or '').strip(), 'metadata': {}})
+            if json.decode(options).get('return_json_metadata', False):
+                return json.encode({'query': re.sub(r'\s+', ' ', query or '').strip(), 'metadata': {}})
         return re.sub(r'\s+', ' ', query or '').strip()
 
     def obfuscate_sql_exec_plan(self, plan, normalize=False):

datadog_checks/base/utils/_http_utils.py

@@ -0,0 +1,51 @@
+# (C) Datadog, Inc. 2025-present
+# All rights reserved
+# Licensed under a 3-clause BSD style license (see LICENSE)
+from __future__ import annotations
+
+from typing import Any
+
+
+def __getattr__(name: str) -> Any:
+    # This is used to lazily load imports when the path contains subpackages
+    if name == 'HostHeaderSSLAdapter':
+        from requests_toolbelt.adapters.host_header_ssl import HostHeaderSSLAdapter
+
+        return HostHeaderSSLAdapter
+
+    if name == 'BotoAWSRequestsAuth':
+        from aws_requests_auth.boto_utils import BotoAWSRequestsAuth
+
+        return BotoAWSRequestsAuth
+
+    if name == 'oauth2':
+        from oauthlib import oauth2
+
+        return oauth2
+
+    if name == 'cryptography_serialization':
+        from cryptography.hazmat.primitives import serialization
+
+        return serialization
+
+    if name == 'cryptography_x509_load_certificate':
+        from cryptography.x509 import load_der_x509_certificate
+
+        return load_der_x509_certificate
+
+    if name == 'cryptography_x509_ExtensionNotFound':
+        from cryptography.x509.extensions import ExtensionNotFound
+
+        return ExtensionNotFound
+
+    if name == 'cryptography_x509_AuthorityInformationAccessOID':
+        from cryptography.x509.oid import AuthorityInformationAccessOID
+
+        return AuthorityInformationAccessOID
+
+    if name == 'cryptography_x509_ExtensionOID':
+        from cryptography.x509.oid import ExtensionOID
+
+        return ExtensionOID
+
+    raise AttributeError(f'`{__name__}` object has no attribute `{name}`')

datadog_checks/base/utils/db/__init__.py

@@ -1,5 +1,6 @@
 # (C) Datadog, Inc. 2019-present
 # All rights reserved
 # Licensed under a 3-clause BSD style license (see LICENSE)
-from .core import QueryExecutor, QueryManager
-from .query import Query
+import lazy_loader
+
+__getattr__, __dir__, __all__ = lazy_loader.attach_stub(__name__, __file__)

datadog_checks/base/utils/db/__init__.pyi

@@ -0,0 +1,7 @@
+# (C) Datadog, Inc. 2025-present
+# All rights reserved
+# Licensed under a 3-clause BSD style license (see LICENSE)
+from .core import QueryExecutor, QueryManager
+from .query import Query
+
+__all__ = ['Query', 'QueryExecutor', 'QueryManager']

datadog_checks/base/utils/db/sql.py

@@ -7,7 +7,7 @@ from __future__ import unicode_literals
 import mmh3
 
 from datadog_checks.base import ensure_bytes
-from datadog_checks.base.utils.serialization import json, sort_keys_kwargs
+from datadog_checks.base.utils.format import json
 
 # Unicode character "Arabic Decimal Separator" (U+066B) is a character which looks like an ascii
 # comma, but is not treated like a comma when parsing metrics tags. This is used to replace
@@ -52,5 +52,5 @@ def compute_exec_plan_signature(normalized_json_plan):
     """
     if not normalized_json_plan:
         return None
-    with_sorted_keys = json.dumps(json.loads(normalized_json_plan), **sort_keys_kwargs)
+    with_sorted_keys = json.encode(json.decode(normalized_json_plan), sort_keys=True)
     return format(mmh3.hash64(with_sorted_keys, signed=False)[0], 'x')

datadog_checks/base/utils/db/utils.py

@@ -20,7 +20,7 @@ from datadog_checks.base import is_affirmative
 from datadog_checks.base.agent import datadog_agent
 from datadog_checks.base.log import get_check_logger
 from datadog_checks.base.utils.db.types import Transformer  # noqa: F401
-from datadog_checks.base.utils.serialization import json
+from datadog_checks.base.utils.format import json
 from datadog_checks.base.utils.tracing import INTEGRATION_TRACING_SERVICE_NAME, tracing_enabled
 
 from ..common import to_native_string
@@ -193,7 +193,7 @@ def get_agent_host_tags():
     if not host_tags:
         return result
     try:
-        tags_dict = json.loads(host_tags) or {}
+        tags_dict = json.decode(host_tags) or {}
         for key, value in tags_dict.items():
             if isinstance(value, list):
                 result.extend(value)
@@ -250,7 +250,7 @@ def obfuscate_sql_with_metadata(query, options=None, replace_null_character=Fals
     if not statement.startswith('{'):
         return {'query': statement, 'metadata': {}}
 
-    statement_with_metadata = json.loads(statement)
+    statement_with_metadata = json.decode(statement)
     metadata = statement_with_metadata.get('metadata', {})
     tables = metadata.pop('tables_csv', None)
     tables = [table.strip() for table in tables.split(',') if table != ''] if tables else None

datadog_checks/base/utils/discovery/__init__.py

@@ -1,4 +1,6 @@
 # (C) Datadog, Inc. 2023-present
 # All rights reserved
 # Licensed under a 3-clause BSD style license (see LICENSE)
-from .discovery import Discovery
+import lazy_loader
+
+__getattr__, __dir__, __all__ = lazy_loader.attach_stub(__name__, __file__)

datadog_checks/base/utils/discovery/__init__.pyi

@@ -0,0 +1,6 @@
+# (C) Datadog, Inc. 2025-present
+# All rights reserved
+# Licensed under a 3-clause BSD style license (see LICENSE)
+from .discovery import Discovery
+
+__all__ = ['Discovery']

datadog_checks/base/utils/format/__init__.py

@@ -0,0 +1,3 @@
+# (C) Datadog, Inc. 2025-present
+# All rights reserved
+# Licensed under a 3-clause BSD style license (see LICENSE)

datadog_checks/base/utils/format/_json.py

@@ -0,0 +1,43 @@
+# (C) Datadog, Inc. 2025-present
+# All rights reserved
+# Licensed under a 3-clause BSD style license (see LICENSE)
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+logger = logging.getLogger(__name__)
+
+try:
+    import orjson
+
+    logger.debug('Using JSON implementation from orjson')
+
+    def decode(s: str | bytes) -> Any:
+        return orjson.loads(s)
+
+    def encode(obj: Any, *, sort_keys: bool = False, default: Callable[[Any], Any] | None = None) -> str:
+        return encode_bytes(obj, sort_keys=sort_keys, default=default).decode()
+
+    def encode_bytes(obj: Any, *, sort_keys: bool = False, default: Callable[[Any], Any] | None = None) -> bytes:
+        if sort_keys:
+            return orjson.dumps(obj, option=orjson.OPT_SORT_KEYS, default=default)
+
+        return orjson.dumps(obj, default=default)
+
+except ImportError:
+    import json
+
+    logger.debug('Using JSON implementation from stdlib')
+
+    def decode(s: str | bytes) -> Any:
+        return json.loads(s)
+
+    def encode(obj: Any, *, sort_keys: bool = False, default: Callable[[Any], Any] | None = None) -> str:
+        return json.dumps(obj, sort_keys=sort_keys, separators=(',', ':'), default=default)
+
+    def encode_bytes(obj: Any, *, sort_keys: bool = False, default: Callable[[Any], Any] | None = None) -> bytes:
+        return encode(obj, sort_keys=sort_keys, default=default).encode()