datadog-checks-base 37.4.0__tar.gz → 37.6.1__tar.gz

{datadog_checks_base-37.4.0 → datadog_checks_base-37.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datadog-checks-base
-Version: 37.4.0
+Version: 37.6.1
 Summary: The Datadog Check Toolkit
 Project-URL: Source, https://github.com/DataDog/integrations-core
 Author-email: Datadog <packages@datadoghq.com>
@@ -13,40 +13,39 @@ Classifier: License :: OSI Approved :: BSD License
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: System :: Monitoring
 Provides-Extra: db
-Requires-Dist: mmh3==4.1.0; extra == 'db'
+Requires-Dist: mmh3==5.1.0; extra == 'db'
 Provides-Extra: deps
 Requires-Dist: binary==1.0.1; extra == 'deps'
-Requires-Dist: cachetools==5.5.0; extra == 'deps'
+Requires-Dist: cachetools==5.5.1; extra == 'deps'
 Requires-Dist: cryptography==43.0.1; extra == 'deps'
 Requires-Dist: ddtrace==2.10.6; extra == 'deps'
-Requires-Dist: importlib-metadata==2.1.3; (python_version < '3.8') and extra == 'deps'
-Requires-Dist: jellyfish==1.1.0; extra == 'deps'
-Requires-Dist: prometheus-client==0.20.0; extra == 'deps'
-Requires-Dist: protobuf==5.27.3; extra == 'deps'
-Requires-Dist: pydantic==2.8.2; extra == 'deps'
+Requires-Dist: jellyfish==1.1.3; extra == 'deps'
+Requires-Dist: prometheus-client==0.21.1; extra == 'deps'
+Requires-Dist: protobuf==5.29.3; extra == 'deps'
+Requires-Dist: pydantic==2.10.6; extra == 'deps'
 Requires-Dist: python-dateutil==2.9.0.post0; extra == 'deps'
-Requires-Dist: pywin32==306; (sys_platform == 'win32') and extra == 'deps'
+Requires-Dist: pywin32==308; (sys_platform == 'win32') and extra == 'deps'
 Requires-Dist: pyyaml==6.0.2; extra == 'deps'
 Requires-Dist: requests-toolbelt==1.0.0; extra == 'deps'
 Requires-Dist: requests-unixsocket2==0.4.2; extra == 'deps'
 Requires-Dist: requests==2.32.3; extra == 'deps'
 Requires-Dist: simplejson==3.19.3; extra == 'deps'
 Requires-Dist: uptime==3.0.1; extra == 'deps'
-Requires-Dist: wrapt==1.16.0; extra == 'deps'
+Requires-Dist: wrapt==1.17.2; extra == 'deps'
 Provides-Extra: http
 Requires-Dist: aws-requests-auth==0.4.3; extra == 'http'
-Requires-Dist: botocore==1.35.10; extra == 'http'
+Requires-Dist: botocore==1.36.16; extra == 'http'
 Requires-Dist: oauthlib==3.2.2; extra == 'http'
-Requires-Dist: pyjwt==2.9.0; extra == 'http'
+Requires-Dist: pyjwt==2.10.1; extra == 'http'
 Requires-Dist: pyopenssl==24.2.1; extra == 'http'
 Requires-Dist: pysocks==1.7.1; extra == 'http'
 Requires-Dist: requests-kerberos==0.15.0; extra == 'http'
 Requires-Dist: requests-ntlm==1.3.0; extra == 'http'
 Requires-Dist: requests-oauthlib==2.0.0; extra == 'http'
 Provides-Extra: json
-Requires-Dist: orjson==3.10.7; extra == 'json'
+Requires-Dist: orjson==3.10.15; extra == 'json'
 Provides-Extra: kube
-Requires-Dist: kubernetes==30.1.0; extra == 'kube'
+Requires-Dist: kubernetes==32.0.0; extra == 'kube'
 Requires-Dist: requests-oauthlib==2.0.0; extra == 'kube'
 Description-Content-Type: text/markdown
 

{datadog_checks_base-37.4.0 → datadog_checks_base-37.6.1}/datadog_checks/base/__about__.py

@@ -1,4 +1,4 @@
 # (C) Datadog, Inc. 2018-present
 # All rights reserved
 # Licensed under a 3-clause BSD style license (see LICENSE)
-__version__ = "37.4.0"
+__version__ = "37.6.1"

{datadog_checks_base-37.4.0 → datadog_checks_base-37.6.1}/datadog_checks/base/checks/openmetrics/v2/labels.py

@@ -1,21 +1,27 @@
 # (C) Datadog, Inc. 2020-present
 # All rights reserved
 # Licensed under a 3-clause BSD style license (see LICENSE)
+from collections import ChainMap
+
 from ....utils.functions import no_op
 
 
 class LabelAggregator:
     def __init__(self, check, config):
         share_labels = config.get('share_labels', {})
-        if not isinstance(share_labels, dict):
-            raise TypeError('Setting `share_labels` must be a mapping')
-        elif not share_labels:
+        self.target_info = config.get('target_info', False)
+        self.target_info_labels = {}
+
+        self._validate_type(share_labels, dict, "Setting `share_labels` must be a mapping")
+        self._validate_type(self.target_info, bool, "Setting `target_info` must be a boolean")
+
+        if not share_labels and not self.target_info:
             self.populate = no_op
             return
 
         self.cache_shared_labels = config.get('cache_shared_labels', True)
         self.shared_labels_cached = False
-
+        self.info_metric = {'target_info': {}}
         self.metric_config = {}
         for metric, config in share_labels.items():
             data = self.metric_config[metric] = {}
@@ -31,6 +37,7 @@ class LabelAggregator:
                     raise TypeError(f'Option `values` for metric `{metric}` of setting `share_labels` must be an array')
 
                 allowed_values = set()
+
                 for i, value in enumerate(values, 1):
                     value = str(value)
 
@@ -72,34 +79,32 @@ class LabelAggregator:
 
         self.unconditional_labels = {}
 
+    def _validate_type(self, value, expected_type, error_message):
+        if not isinstance(value, expected_type):
+            raise TypeError(error_message)
+
     def __call__(self, metrics):
         if self.cache_shared_labels:
             if self.shared_labels_cached:
                 yield from metrics
             else:
-                metric_config = self.metric_config.copy()
+                metric_config, target_info_metric = self.copy_configs()
 
                 for metric in metrics:
-                    if metric_config and metric.name in metric_config:
-                        self.collect(metric, metric_config.pop(metric.name))
-
+                    self.process_metric(metric, metric_config, target_info_metric)
                     yield metric
 
                 self.shared_labels_cached = True
         else:
             try:
-                metric_config = self.metric_config.copy()
-
-                # Cache every encountered metric until the desired labels have been collected
+                metric_config, target_info_metric = self.copy_configs()
                 cached_metrics = []
 
                 for metric in metrics:
-                    if metric.name in metric_config:
-                        self.collect(metric, metric_config.pop(metric.name))
-
+                    self.process_metric(metric, metric_config, target_info_metric)
                     cached_metrics.append(metric)
 
-                    if not metric_config:
+                    if not (metric_config or target_info_metric):
                         break
 
                 yield from cached_metrics
@@ -108,6 +113,24 @@ class LabelAggregator:
                 self.label_sets.clear()
                 self.unconditional_labels.clear()
 
+    def copy_configs(self):
+        return self.metric_config.copy(), self.info_metric.copy()
+
+    def process_metric(self, metric, *configs):
+        """
+        Collects labels from shared_labels + target_info metrics
+        """
+        for config in configs:
+            if config and metric.name in config:
+                self.collect(metric, config.pop(metric.name))
+
+    def process_target_info(self, metric):
+        """
+        Updates cached target info metrics
+        """
+        if metric.samples[0].labels != self.target_info_labels:
+            self.target_info_labels = metric.samples[0].labels
+
     def collect(self, metric, config):
         allowed_values = config.get('values')
 
@@ -147,13 +170,28 @@ class LabelAggregator:
                         if label in labels:
                             self.unconditional_labels[label] = value
             else:
-                for sample in self.allowed_samples(metric, allowed_values):
-                    for label, value in sample.labels.items():
-                        self.unconditional_labels[label] = value
+                # Store target_info metric labels to be applied to other metrics in payload
+                if metric.name == 'target_info':
+                    self.target_info_labels.update(
+                        {
+                            label: value
+                            for sample in self.allowed_samples(metric, allowed_values)
+                            for label, value in sample.labels.items()
+                        }
+                    )
+                else:
+                    # Store shared labels in a seperate attribute
+                    self.unconditional_labels.update(
+                        {
+                            label: value
+                            for sample in self.allowed_samples(metric, allowed_values)
+                            for label, value in sample.labels.items()
+                        }
+                    )
 
     def populate(self, labels):
         label_set = frozenset(labels.items())
-        labels.update(self.unconditional_labels)
+        labels.update(ChainMap(self.unconditional_labels, self.target_info_labels))
 
         for matching_label_set, shared_labels in self.label_sets:
             # Check for subset without incurring the cost of a `.issubset` lookup and call

{datadog_checks_base-37.4.0 → datadog_checks_base-37.6.1}/datadog_checks/base/checks/openmetrics/v2/scraper.py

@@ -58,6 +58,7 @@ class OpenMetricsScraper:
 
         # Parse the configuration
         self.endpoint = config['openmetrics_endpoint']
+        self.target_info = config.get('target_info', False)
 
         self.metric_transformer = MetricTransformer(self.check, config)
         self.label_aggregator = LabelAggregator(self.check, config)
@@ -238,7 +239,13 @@ class OpenMetricsScraper:
         """
         runtime_data = {'flush_first_value': self.flush_first_value, 'static_tags': self.static_tags}
 
-        for metric in self.consume_metrics(runtime_data):
+        # Determine which consume method to use based on target_info config
+        if self.target_info:
+            consume_method = self.consume_metrics_w_target_info
+        else:
+            consume_method = self.consume_metrics
+
+        for metric in consume_method(runtime_data):
             transformer = self.metric_transformer.get(metric)
             if transformer is None:
                 continue
@@ -248,23 +255,52 @@ class OpenMetricsScraper:
         self.flush_first_value = True
 
     def consume_metrics(self, runtime_data):
+        """
+        Yield the processed metrics and filter out excluded metrics, without checking for target_info metrics.
+        """
+
+        metric_parser = self.parse_metrics()
+
+        if not self.flush_first_value and self.use_process_start_time:
+            metric_parser = first_scrape_handler(metric_parser, runtime_data, datadog_agent.get_process_start_time())
+        if self.label_aggregator.configured:
+            metric_parser = self.label_aggregator(metric_parser)
+
+        for metric in metric_parser:
+            # Skip excluded metrics
+            if metric.name in self.exclude_metrics or (
+                self.exclude_metrics_pattern is not None and self.exclude_metrics_pattern.search(metric.name)
+            ):
+                self.submit_telemetry_number_of_ignored_metric_samples(metric)
+                continue
+
+            yield metric
+
+    def consume_metrics_w_target_info(self, runtime_data):
         """
         Yield the processed metrics and filter out excluded metrics.
+        Additionally, handle target_info metrics.
         """
 
         metric_parser = self.parse_metrics()
+
         if not self.flush_first_value and self.use_process_start_time:
             metric_parser = first_scrape_handler(metric_parser, runtime_data, datadog_agent.get_process_start_time())
         if self.label_aggregator.configured:
             metric_parser = self.label_aggregator(metric_parser)
 
         for metric in metric_parser:
+            # Skip excluded metrics
             if metric.name in self.exclude_metrics or (
                 self.exclude_metrics_pattern is not None and self.exclude_metrics_pattern.search(metric.name)
             ):
                 self.submit_telemetry_number_of_ignored_metric_samples(metric)
                 continue
 
+            # Process target_info metrics
+            if metric.name == 'target_info':
+                self.label_aggregator.process_target_info(metric)
+
             yield metric
 
     def parse_metrics(self):
@@ -312,7 +348,6 @@ class OpenMetricsScraper:
         """
         Yield a sample of processed data.
         """
-
         label_normalizer = get_label_normalizer(metric.type)
 
         for sample in metric.samples:

{datadog_checks_base-37.4.0 → datadog_checks_base-37.6.1}/datadog_checks/base/utils/agent/packages.py

@@ -1,12 +1,7 @@
 # (C) Datadog, Inc. 2019-present
 # All rights reserved
 # Licensed under a 3-clause BSD style license (see LICENSE)
-import sys
-
-if sys.version_info >= (3, 8):
-    from importlib.metadata import distributions
-else:
-    from importlib_metadata import distributions
+from importlib.metadata import distributions
 
 DATADOG_CHECK_PREFIX = 'datadog-'
 

{datadog_checks_base-37.4.0 → datadog_checks_base-37.6.1}/datadog_checks/base/utils/http.py

@@ -52,6 +52,8 @@ LOGGER = logging.getLogger(__file__)
 # https://tools.ietf.org/html/rfc2988
 DEFAULT_TIMEOUT = 10
 
+DEFAULT_EXPIRATION = 300
+
 # 16 KiB seems optimal, and is also the standard chunk size of the Bittorrent protocol:
 # https://www.bittorrent.org/beps/bep_0003.html
 DEFAULT_CHUNK_SIZE = 16
@@ -92,6 +94,7 @@ STANDARD_FIELDS = {
     'tls_private_key': None,
     'tls_protocols_allowed': DEFAULT_PROTOCOL_VERSIONS,
     'tls_verify': True,
+    'tls_ciphers': 'ALL',
     'timeout': DEFAULT_TIMEOUT,
     'use_legacy_auth_encoding': True,
     'username': None,
@@ -153,6 +156,7 @@ class RequestsWrapper(object):
         'auth_token_handler',
         'request_size',
         'tls_protocols_allowed',
+        'tls_ciphers_allowed',
     )
 
     def __init__(self, instance, init_config, remapper=None, logger=None, session=None):
@@ -347,6 +351,14 @@ class RequestsWrapper(object):
         if config['kerberos_cache']:
             self.request_hooks.append(lambda: handle_kerberos_cache(config['kerberos_cache']))
 
+        ciphers = config.get('tls_ciphers')
+        if ciphers:
+            if 'ALL' in ciphers:
+                updated_ciphers = "ALL"
+            else:
+                updated_ciphers = ":".join(ciphers)
+        self.tls_ciphers_allowed = updated_ciphers
+
     def get(self, url, **options):
         return self._request('get', url, options)
 
@@ -465,6 +477,7 @@ class RequestsWrapper(object):
             try:
                 context = ssl.SSLContext(protocol=ssl.PROTOCOL_TLS)
                 context.verify_mode = ssl.CERT_NONE
+                context.set_ciphers(self.tls_ciphers_allowed)
 
                 with context.wrap_socket(sock, server_hostname=hostname) as secure_sock:
                     der_cert = secure_sock.getpeercert(binary_form=True)
@@ -856,8 +869,16 @@ class AuthTokenOAuthReader(object):
 
             # https://www.rfc-editor.org/rfc/rfc6749#section-4.4.3
             self._token = response['access_token']
-            self._expiration = get_timestamp() + response['expires_in']
-
+            self._expiration = get_timestamp()
+            try:
+                # According to https://www.rfc-editor.org/rfc/rfc6749#section-5.1, the `expires_in` field is optional
+                self._expiration += _parse_expires_in(response.get('expires_in'))
+            except TypeError:
+                LOGGER.debug(
+                    'The `expires_in` field of the OAuth2 response is not a number, defaulting to %s',
+                    DEFAULT_EXPIRATION,
+                )
+                self._expiration += DEFAULT_EXPIRATION
             return self._token
 
 
@@ -991,6 +1012,21 @@ def quote_uds_url(url):
     return urlunparse(parsed)
 
 
+def _parse_expires_in(token_expiration):
+    if isinstance(token_expiration, int) or isinstance(token_expiration, float):
+        return token_expiration
+    if isinstance(token_expiration, str):
+        try:
+            token_expiration = int(token_expiration)
+        except ValueError:
+            LOGGER.debug('Could not convert %s to an integer', token_expiration)
+    else:
+        LOGGER.debug('Unexpected type for `expires_in`: %s.', type(token_expiration))
+        token_expiration = None
+
+    return token_expiration
+
+
 # For documentation generation
 # TODO: use an enum and remove STANDARD_FIELDS when mkdocstrings supports it
 class StandardFields(object):

{datadog_checks_base-37.4.0 → datadog_checks_base-37.6.1}/pyproject.toml

@@ -31,33 +31,32 @@ license = "BSD-3-Clause"
 
 [project.optional-dependencies]
 db = [
-    "mmh3==4.1.0",
+    "mmh3==5.1.0",
 ]
 deps = [
     "binary==1.0.1",
-    "cachetools==5.5.0",
+    "cachetools==5.5.1",
     "cryptography==43.0.1",
     "ddtrace==2.10.6",
-    "importlib-metadata==2.1.3; python_version < '3.8'",
-    "jellyfish==1.1.0",
-    "prometheus-client==0.20.0",
-    "protobuf==5.27.3",
-    "pydantic==2.8.2",
+    "jellyfish==1.1.3",
+    "prometheus-client==0.21.1",
+    "protobuf==5.29.3",
+    "pydantic==2.10.6",
     "python-dateutil==2.9.0.post0",
-    "pywin32==306; sys_platform == 'win32'",
+    "pywin32==308; sys_platform == 'win32'",
     "pyyaml==6.0.2",
     "requests-toolbelt==1.0.0",
     "requests-unixsocket2==0.4.2",
     "requests==2.32.3",
     "simplejson==3.19.3",
     "uptime==3.0.1",
-    "wrapt==1.16.0",
+    "wrapt==1.17.2",
 ]
 http = [
     "aws-requests-auth==0.4.3",
-    "botocore==1.35.10",
+    "botocore==1.36.16",
     "oauthlib==3.2.2",
-    "pyjwt==2.9.0",
+    "pyjwt==2.10.1",
     "pyopenssl==24.2.1",
     "pysocks==1.7.1",
     "requests-kerberos==0.15.0",
@@ -65,10 +64,10 @@ http = [
     "requests-oauthlib==2.0.0",
 ]
 json = [
-    "orjson==3.10.7",
+    "orjson==3.10.15",
 ]
 kube = [
-    "kubernetes==30.1.0",
+    "kubernetes==32.0.0",
     "requests-oauthlib==2.0.0",
 ]
 

{datadog_checks_base-37.4.0 → datadog_checks_base-37.6.1}/tests/base/checks/logs/crawler/test_base.py

@@ -6,7 +6,6 @@ from datadog_checks.base.checks.logs.crawler.stream import LogRecord, LogStream
 
 
 def test_submission(dd_run_check, datadog_agent):
-
     class TestLogStream(LogStream):
         def __init__(self, start, **kwargs):
             super().__init__(**kwargs)

{datadog_checks_base-37.4.0 → datadog_checks_base-37.6.1}/tests/base/checks/openmetrics/test_v2/test_options.py

@@ -681,6 +681,200 @@ class TestShareLabels:
 
         aggregator.assert_all_metrics_covered()
 
+    def test_target_info_tags_propagation(self, aggregator, dd_run_check, mock_http_response):
+
+        check = get_check({'metrics': ['.+'], 'target_info': True})
+
+        mock_http_response(
+            """
+            # HELP target Target metadata
+            # TYPE target info
+            target_info{env="prod", region="europe"} 1.0
+            # HELP go_memstats_alloc_bytes Number of bytes allocated and still in use.
+            # TYPE go_memstats_alloc_bytes gauge
+            go_memstats_alloc_bytes{foo="bar"} 6.396288e+06
+            """
+        )
+
+        dd_run_check(check)
+
+        aggregator.assert_metric(
+            'test.go_memstats_alloc_bytes',
+            value=6396288,
+            tags=['endpoint:test', 'foo:bar', 'env:prod', 'region:europe'],
+            metric_type=aggregator.GAUGE,
+        )
+
+        aggregator.assert_all_metrics_covered()
+
+    def test_target_info_tags_propagation_unordered(self, aggregator, dd_run_check, mock_http_response):
+
+        check = get_check({'metrics': ['.+'], 'target_info': True, 'cache_shared_labels': False})
+
+        mock_http_response(
+            """
+            # HELP go_memstats_alloc_bytes Number of bytes allocated and still in use.
+            # TYPE go_memstats_alloc_bytes gauge
+            go_memstats_alloc_bytes{foo="bar"} 6.396288e+06
+            # HELP target Target metadata
+            # TYPE target info
+            target_info{env="prod", region="europe"} 1.0
+            """
+        )
+
+        dd_run_check(check)
+
+        aggregator.assert_metric(
+            'test.go_memstats_alloc_bytes',
+            value=6396288,
+            tags=['endpoint:test', 'foo:bar', 'env:prod', 'region:europe'],
+            metric_type=aggregator.GAUGE,
+        )
+
+        aggregator.assert_all_metrics_covered()
+
+    def test_target_info_tags_propagation_unordered_w_cache(self, aggregator, dd_run_check, mock_http_response):
+
+        check = get_check({'metrics': ['.+'], 'target_info': True})
+
+        mock_http_response(
+            """
+            # HELP go_memstats_alloc_bytes Number of bytes allocated and still in use.
+            # TYPE go_memstats_alloc_bytes gauge
+            go_memstats_alloc_bytes{foo="bar"} 6.396288e+06
+            # HELP target Target metadata
+            # TYPE target info
+            target_info{env="prod", region="europe"} 1.0
+            """
+        )
+
+        dd_run_check(check)
+
+        aggregator.assert_metric(
+            'test.go_memstats_alloc_bytes',
+            value=6396288,
+            tags=['endpoint:test', 'foo:bar'],
+            metric_type=aggregator.GAUGE,
+        )
+
+        dd_run_check(check)
+
+        aggregator.assert_metric(
+            'test.go_memstats_alloc_bytes',
+            value=6396288,
+            tags=['endpoint:test', 'foo:bar', 'env:prod', 'region:europe'],
+            metric_type=aggregator.GAUGE,
+        )
+
+        aggregator.assert_all_metrics_covered()
+
+    def test_target_info_update_cache(self, aggregator, dd_run_check, mock_http_response):
+
+        check = get_check({'metrics': ['.+'], 'target_info': True})
+        check_var = check
+
+        mock_http_response(
+            """
+            # HELP target Target metadata
+            # TYPE target info
+            target_info{env="prod", region="europe"} 1.0
+            # HELP go_memstats_alloc_bytes Number of bytes allocated and still in use.
+            # TYPE go_memstats_alloc_bytes gauge
+            go_memstats_alloc_bytes{foo="bar"} 6.396288e+06
+            """
+        )
+
+        dd_run_check(check_var)
+
+        aggregator.assert_metric(
+            'test.go_memstats_alloc_bytes',
+            value=6396288,
+            tags=['endpoint:test', 'foo:bar', 'env:prod', 'region:europe'],
+            metric_type=aggregator.GAUGE,
+        )
+
+        mock_http_response(
+            """
+            # HELP target Target metadata
+            # TYPE target info
+            target_info{env="stg", region="asia"} 1.0
+            # HELP go_memstats_alloc_bytes Number of bytes allocated and still in use.
+            # TYPE go_memstats_alloc_bytes gauge
+            go_memstats_alloc_bytes{foo="bar2"} 6.396288e+06
+            """
+        )
+
+        dd_run_check(check_var)
+
+        aggregator.assert_metric(
+            'test.go_memstats_alloc_bytes',
+            value=6396288,
+            tags=['endpoint:test', 'foo:bar2', 'env:stg', 'region:asia'],
+            metric_type=aggregator.GAUGE,
+        )
+
+        aggregator.assert_all_metrics_covered()
+
+    def test_target_info_w_shared_labels_cache(self, aggregator, dd_run_check, mock_http_response):
+
+        check = get_check({'metrics': ['.+'], 'share_labels': {'go_memstats_free_bytes': True}, 'target_info': True})
+        check_var = check
+
+        mock_http_response(
+            """
+            # HELP target Target metadata
+            # TYPE target info
+            target_info{env="prod", region="europe"} 1.0
+            # HELP go_memstats_free_bytes Number of bytes free and available for use.
+            # TYPE go_memstats_free_bytes gauge
+            go_memstats_free_bytes{foo="bar"} 6.396288e+06
+            # HELP go_memstats_alloc_bytes Number of bytes allocated and still in use.
+            # TYPE go_memstats_alloc_bytes gauge
+            go_memstats_alloc_bytes{bar="foo"} 6.396288e+06
+            """
+        )
+
+        dd_run_check(check_var)
+
+        aggregator.assert_metric(
+            'test.go_memstats_alloc_bytes',
+            value=6396288,
+            tags=['endpoint:test', 'foo:bar', 'bar:foo', 'env:prod', 'region:europe'],
+            metric_type=aggregator.GAUGE,
+        )
+
+        mock_http_response(
+            """
+            # HELP target Target metadata
+            # TYPE target info
+            target_info{env="stg", region="asia"} 1.0
+            # HELP go_memstats_alloc_bytes Number of bytes allocated and still in use.
+            # TYPE go_memstats_alloc_bytes gauge
+            go_memstats_alloc_bytes{foo2="bar2"} 6.396288e+06
+            # HELP go_memstats_free_bytes Number of bytes free and available for use.
+            # TYPE go_memstats_free_bytes gauge
+            go_memstats_free_bytes{bar2="baz2"} 6.396288e+06
+            """
+        )
+
+        dd_run_check(check_var)
+
+        aggregator.assert_metric(
+            'test.go_memstats_alloc_bytes',
+            value=6396288,
+            tags=['endpoint:test', 'foo:bar', 'foo2:bar2', 'env:stg', 'region:asia'],
+            metric_type=aggregator.GAUGE,
+        )
+
+        aggregator.assert_metric(
+            'test.go_memstats_free_bytes',
+            value=6396288,
+            tags=['endpoint:test', 'env:stg', 'region:asia', 'bar2:baz2', 'foo:bar'],
+            metric_type=aggregator.GAUGE,
+        )
+
+        aggregator.assert_all_metrics_covered()
+
 
 class TestIgnoreTags:
     def test_simple_match(self, aggregator, dd_run_check, mock_http_response):