fix

Author: sarah-witt

datadog_checks_dev/datadog_checks/dev/plugin/pytest.py

@@ -320,7 +320,7 @@ def enum_object_items(data_source, machine_name, object_name, detail_level):
         counters = {}
         for object_name, data in perf_objects.items():
             instances, counter_values = data
-            instance_counts = {instance_name: 0 for instance_name in instances}
+            instance_counts = dict.fromkeys(instances, 0)
             instance_indices = []
             for instance_name in instances:
                 instance_indices.append(instance_counts[instance_name])

dns_check/tests/mocks.py

@@ -17,7 +17,7 @@ def __init__(self, address):
             else:
                 items = [MockDNSAnswer.MockItem(address)]
 
-            self.items = {item: None for item in items}
+            self.items = dict.fromkeys(items)
 
     class MockItem:
         def __init__(self, address):

haproxy/datadog_checks/haproxy/legacy/haproxy.py

@@ -453,7 +453,7 @@ def _normalize_status(status):
         return formatted_status
 
     def _process_backend_hosts_metric(self, active_tag=None):
-        agg_statuses = defaultdict(lambda: {status: 0 for status in Services.COLLATED_STATUSES})
+        agg_statuses = defaultdict(lambda: dict.fromkeys(Services.COLLATED_STATUSES, 0))
         active_tag = [] if active_tag is None else active_tag
 
         for host_status, count in self.hosts_statuses.items():
@@ -493,7 +493,7 @@ def _process_status_metric(
         self,
         active_tag=None,
     ):
-        agg_statuses_counter = defaultdict(lambda: {status: 0 for status in Services.COLLATED_STATUSES})
+        agg_statuses_counter = defaultdict(lambda: dict.fromkeys(Services.COLLATED_STATUSES, 0))
         active_tag = [] if active_tag is None else active_tag
         # Initialize `statuses_counter`: every value is a defaultdict initialized with the correct
         # keys, which depends on the `collate_status_tags_per_host` option

http_check/tests/conftest.py

@@ -43,7 +43,7 @@ def call_endpoint(url):
 
 @pytest.fixture(scope='session')
 def mock_local_http_dns():
-    mapping = {x: ('127.0.0.1', 443) for x in MOCKED_HOSTS}
+    mapping = dict.fromkeys(MOCKED_HOSTS, ('127.0.0.1', 443))
     with mock_local(mapping):
         yield
 

kubelet/datadog_checks/kubelet/kubelet.py

@@ -228,13 +228,13 @@ def __init__(self, name, init_config, instances):
 
         self.probes_scraper_config = self.get_scraper_config(probes_instance)
 
-        counter_transformers = {k: self.send_always_counter for k in self.COUNTER_METRICS}
+        counter_transformers = dict.fromkeys(self.COUNTER_METRICS, self.send_always_counter)
 
         histogram_transformers = {
             k: self._histogram_from_seconds_to_microseconds(v) for k, v in TRANSFORM_VALUE_HISTOGRAMS.items()
         }
 
-        volume_metric_transformers = {k: self.append_pod_tags_to_volume_metrics for k in self.VOLUME_METRICS}
+        volume_metric_transformers = dict.fromkeys(self.VOLUME_METRICS, self.append_pod_tags_to_volume_metrics)
 
         self.transformers = {}
         for d in [

kubelet/datadog_checks/kubelet/prometheus.py

@@ -367,7 +367,7 @@ def _process_usage_metric(self, m_name, metric, cache, scraper_config, labels=No
             labels = []
 
         # track containers that still exist in the cache
-        seen_keys = {k: False for k in cache}
+        seen_keys = dict.fromkeys(cache, False)
 
         samples = self._sum_values_by_context(metric, self._get_entity_id_if_container_metric)
         for c_id, sample in samples.items():

mapreduce/tests/common.py

@@ -82,7 +82,7 @@ def setup_mapreduce():
 
 @contextmanager
 def mock_local_mapreduce_dns():
-    mapping = {x: ('127.0.0.1', None) for x in MOCKED_E2E_HOSTS}
+    mapping = dict.fromkeys(MOCKED_E2E_HOSTS, ('127.0.0.1', None))
     with mock_local(mapping):
         yield
 

mongo/datadog_checks/mongo/discovery.py

@@ -17,7 +17,7 @@ def __init__(self, check):
 
         super(MongoDBDatabaseAutodiscovery, self).__init__(
             self._list_databases,
-            include={db: 0 for db in self._autodiscovery_config.get("include", [".*"])},
+            include=dict.fromkeys(self._autodiscovery_config.get("include", [".*"]), 0),
             exclude=self._autodiscovery_config.get("exclude"),
             interval=self._autodiscovery_config.get('refresh_interval', DEFAULT_REFRESH_INTERVAL),
         )

network/datadog_checks/network/network.py

@@ -317,7 +317,7 @@ def get_net_proc_base_location(proc_location):
         return net_proc_base_location
 
     def _get_metrics(self):
-        return {val: 0 for val in self.cx_state_gauge.values()}
+        return dict.fromkeys(self.cx_state_gauge.values(), 0)
 
     def parse_cx_state(self, lines, tcp_states, state_col, protocol=None, ip_version=None):
         """

process/tests/test_process.py

@@ -168,7 +168,7 @@ def mock_psutil_wrapper(method, accessors):
     if accessors is None:
         result = 0
     else:
-        result = {accessor: 0 for accessor in accessors}
+        result = dict.fromkeys(accessors, 0)
     return result
 
 

rabbitmq/datadog_checks/rabbitmq/rabbitmq.py

@@ -490,7 +490,7 @@ def get_connections_stat(self, instance, base_url, object_type, vhosts, limit_vh
         if grab_all_data or not len(data):
             data = self._get_data(urljoin(base_url, object_type))
 
-        stats = {vhost: 0 for vhost in vhosts}
+        stats = dict.fromkeys(vhosts, 0)
         connection_states = defaultdict(int)
         for conn in data:
             if conn['vhost'] in vhosts:

teleport/datadog_checks/teleport/metrics.py

@@ -208,10 +208,10 @@
 }
 
 METRIC_MAP_BY_SERVICE = {
-    **{metric: "teleport" for metric in COMMON_METRICS_MAP.keys()},
-    **{metric: "proxy" for metric in PROXY_METRICS_MAP.keys()},
-    **{metric: "auth" for metric in AUTH_METRICS_MAP.keys()},
-    **{metric: "ssh" for metric in SSH_METRICS_MAP.keys()},
-    **{metric: "kubernetes" for metric in KUBERNETES_METRICS_MAP.keys()},
-    **{metric: "database" for metric in DATABASE_METRICS_MAP.keys()},
+    **dict.fromkeys(COMMON_METRICS_MAP.keys(), "teleport"),
+    **dict.fromkeys(PROXY_METRICS_MAP.keys(), "proxy"),
+    **dict.fromkeys(AUTH_METRICS_MAP.keys(), "auth"),
+    **dict.fromkeys(SSH_METRICS_MAP.keys(), "ssh"),
+    **dict.fromkeys(KUBERNETES_METRICS_MAP.keys(), "kubernetes"),
+    **dict.fromkeys(DATABASE_METRICS_MAP.keys(), "database"),
 }

temporal/scripts/generate_metadata.py

@@ -41,7 +41,7 @@ def main():
 
     def append_metric_metadata(metric_name, metric_type='count', unit_name=None):
         qualified_metric_name = f'temporal.server.{metric_name}'
-        metric_meta = {k: '' for k in metadata_fields}
+        metric_meta = dict.fromkeys(metadata_fields, '')
         metric_meta['orientation'] = 0
         metric_meta.update(previous_metadata.get(qualified_metric_name, {}))
         metric_meta['integration'] = 'temporal'

torchserve/datadog_checks/torchserve/model_discovery.py

@@ -11,7 +11,7 @@ def __init__(self, check, limit=None, include=None, exclude=None, interval=None)
         super().__init__(
             self.get_models,
             limit=limit,
-            include={pattern: None for pattern in include} if include else None,
+            include=dict.fromkeys(include) if include else None,
             exclude=exclude,
             interval=interval,
             key=lambda n: n.get("modelName"),