style: fix error [SIM102] - Use a single if statement instead of nested if statements.

Used Ruff (vscode and pre-commit) to:
- Black-compatible code formatting.
- fix all auto-fixable violations.
- isort-compatible import sorting.
- flake8-simplify manual fixes.

Signed-off-by: Paulo Vital <paulo.vital@ibm.com>

Author: pvital

src/instana/autoprofile/frame_cache.py

@@ -33,9 +33,8 @@ def is_profiler_frame(self, filename: str) -> bool:
 
         profiler_frame = False
 
-        if not self.include_profiler_frames:
-            if filename.startswith(self.profiler_dir):
-                profiler_frame = True
+        if not self.include_profiler_frames and filename.startswith(self.profiler_dir):
+            profiler_frame = True
 
         if len(self.profiler_frame_cache) < self.MAX_CACHE_SIZE:
             self.profiler_frame_cache[filename] = profiler_frame

src/instana/autoprofile/samplers/cpu_sampler.py

@@ -82,13 +82,12 @@ def build_profile(self, duration: int, timespan: int) -> Profile:
             return profile
 
     def process_sample(self, signal_frame: "FrameType") -> None:
-        if self.top:
-            if signal_frame:
-                stack = self.recover_stack(signal_frame)
-                if stack:
-                    self.update_profile(self.top, stack)
+        if self.top and signal_frame:
+            stack = self.recover_stack(signal_frame)
+            if stack:
+                self.update_profile(self.top, stack)
 
-                stack = None
+            stack = None
 
     def recover_stack(
         self, signal_frame: "FrameType"

src/instana/collector/helpers/fargate/process.py

@@ -6,19 +6,22 @@
 
 
 class FargateProcessHelper(ProcessHelper):
-    """ Helper class to extend the generic process helper class with the corresponding fargate attributes """
+    """Helper class to extend the generic process helper class with the corresponding fargate attributes"""
 
     def collect_metrics(self, **kwargs):
         plugin_data = dict()
         try:
             plugin_data = super(FargateProcessHelper, self).collect_metrics(**kwargs)
             plugin_data["data"]["containerType"] = "docker"
             if self.collector.root_metadata is not None:
-                plugin_data["data"]["container"] = self.collector.root_metadata.get("DockerId")
+                plugin_data["data"]["container"] = self.collector.root_metadata.get(
+                    "DockerId"
+                )
 
-            if kwargs.get("with_snapshot"):
-                if self.collector.task_metadata is not None:
-                    plugin_data["data"]["com.instana.plugin.host.name"] = self.collector.task_metadata.get("TaskArn")
+            if kwargs.get("with_snapshot") and self.collector.task_metadata is not None:
+                plugin_data["data"]["com.instana.plugin.host.name"] = (
+                    self.collector.task_metadata.get("TaskArn")
+                )
         except Exception:
             logger.debug("FargateProcessHelper.collect_metrics: ", exc_info=True)
         return [plugin_data]

src/instana/fsm.py

@@ -33,25 +33,23 @@ def __init__(self, agent: "HostAgent") -> None:
         self._warned_periodic = False
 
         self.agent = agent
-        self.fsm = Fysom(
-            {
-                "initial": "*",
-                "events": [
-                    ("lookup", "*", "found"),
-                    ("announce", "found", "announced"),
-                    ("pending", "announced", "wait4init"),
-                    ("ready", "wait4init", "good2go"),
-                ],
-                "callbacks": {
-                    # Can add the following to debug
-                    # "onchangestate": self.print_state_change,
-                    "onlookup": self.lookup_agent_host,
-                    "onannounce": self.announce_sensor,
-                    "onpending": self.on_ready,
-                    "ongood2go": self.on_good2go,
-                },
-            }
-        )
+        self.fsm = Fysom({
+            "initial": "*",
+            "events": [
+                ("lookup", "*", "found"),
+                ("announce", "found", "announced"),
+                ("pending", "announced", "wait4init"),
+                ("ready", "wait4init", "good2go"),
+            ],
+            "callbacks": {
+                # Can add the following to debug
+                # "onchangestate": self.print_state_change,
+                "onlookup": self.lookup_agent_host,
+                "onannounce": self.announce_sensor,
+                "onpending": self.on_ready,
+                "ongood2go": self.on_good2go,
+            },
+        })
 
         with self._lock:
             self.timer = threading.Timer(1, self._safe_fsm_lookup)
@@ -103,12 +101,11 @@ def lookup_agent_host(self, e: Any) -> bool:
 
         if os.path.exists("/proc/"):
             host = get_default_gateway()
-            if host:
-                if self.agent.is_agent_listening(host, port):
-                    self.agent.options.agent_host = host
-                    self.agent.options.agent_port = port
-                    self._safe_fsm_announce()
-                    return True
+            if host and self.agent.is_agent_listening(host, port):
+                self.agent.options.agent_host = host
+                self.agent.options.agent_port = port
+                self._safe_fsm_announce()
+                return True
 
         with self._lock:
             if self._warned_periodic is False:
@@ -141,9 +138,10 @@ def announce_sensor(self, e: Any) -> bool:
                 # PermissionError: [Errno 13] Permission denied: '/proc/6/fd/8'
                 # Use a try/except as a safety
                 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                sock.connect(
-                    (self.agent.options.agent_host, self.agent.options.agent_port)
-                )
+                sock.connect((
+                    self.agent.options.agent_host,
+                    self.agent.options.agent_port,
+                ))
                 path = f"/proc/{pid}/fd/{sock.fileno()}"
                 d.fd = sock.fileno()
                 d.inode = os.readlink(path)

src/instana/instrumentation/kafka/kafka_python.py

@@ -60,7 +60,7 @@ def trace_kafka_send(
             # Context propagation
             headers = kwargs.get("headers", [])
 
-            if not is_suppressed and ("x_instana_l_s", b"0") in headers:
+            if not is_suppressed and headers and ("x_instana_l_s", b"0") in headers:
                 is_suppressed = True
 
             suppression_header = {"x_instana_l_s": "0" if is_suppressed else "1"}
@@ -112,9 +112,8 @@ def create_span(
                     attributes_to_check
                 )
 
-            if not is_suppressed and headers:
-                if ("x_instana_l_s", b"0") in headers:
-                    is_suppressed = True
+            if not is_suppressed and headers and ("x_instana_l_s", b"0") in headers:
+                is_suppressed = True
 
             if is_suppressed:
                 return

src/instana/options.py

@@ -28,9 +28,9 @@
     get_stack_trace_config_from_yaml,
     is_truthy,
     parse_filter_rules,
+    parse_filter_rules_env_vars,
     parse_filter_rules_yaml,
     parse_span_disabling,
-    parse_filter_rules_env_vars,
     parse_technology_stack_trace_config,
     validate_stack_trace_length,
     validate_stack_trace_level,
@@ -123,45 +123,45 @@ def _add_instana_agent_span_filter(self) -> None:
         """Add Instana agent span filter to exclude internal spans."""
         if "exclude" not in self.span_filters:
             self.span_filters["exclude"] = []
-        self.span_filters["exclude"].extend(
-            [
-                {
-                    "name": "filter-internal-spans-by-url",
-                    "attributes": [
-                        {
-                            "key": "http.url",
-                            "values": ["com.instana"],
-                            "match_type": "contains",
-                        }
-                    ],
-                },
-                {
-                    "name": "filter-internal-spans-by-host",
-                    "attributes": [
-                        {
-                            "key": "http.host",
-                            "values": ["com.instana"],
-                            "match_type": "contains",
-                        }
-                    ],
-                },
-            ]
-        )
+        self.span_filters["exclude"].extend([
+            {
+                "name": "filter-internal-spans-by-url",
+                "attributes": [
+                    {
+                        "key": "http.url",
+                        "values": ["com.instana"],
+                        "match_type": "contains",
+                    }
+                ],
+            },
+            {
+                "name": "filter-internal-spans-by-host",
+                "attributes": [
+                    {
+                        "key": "http.host",
+                        "values": ["com.instana"],
+                        "match_type": "contains",
+                    }
+                ],
+            },
+        ])
 
     def _apply_env_stack_trace_config(self) -> None:
         """Apply stack trace configuration from environment variables."""
-        if "INSTANA_STACK_TRACE" in os.environ:
-            if validated_level := validate_stack_trace_level(
+        if "INSTANA_STACK_TRACE" in os.environ and (
+            validated_level := validate_stack_trace_level(
                 os.environ["INSTANA_STACK_TRACE"], "from INSTANA_STACK_TRACE"
-            ):
-                self.stack_trace_level = validated_level
+            )
+        ):
+            self.stack_trace_level = validated_level
 
-        if "INSTANA_STACK_TRACE_LENGTH" in os.environ:
-            if validated_length := validate_stack_trace_length(
+        if "INSTANA_STACK_TRACE_LENGTH" in os.environ and (
+            validated_length := validate_stack_trace_length(
                 os.environ["INSTANA_STACK_TRACE_LENGTH"],
                 "from INSTANA_STACK_TRACE_LENGTH",
-            ):
-                self.stack_trace_length = validated_length
+            )
+        ):
+            self.stack_trace_length = validated_length
 
     def _apply_yaml_stack_trace_config(self) -> None:
         """Apply stack trace configuration from YAML file."""
@@ -182,20 +182,26 @@ def _apply_in_code_stack_trace_config(self) -> None:
 
         global_config = config["tracing"]["global"]
 
-        if "INSTANA_STACK_TRACE" not in os.environ and "stack_trace" in global_config:
-            if validated_level := validate_stack_trace_level(
-                global_config["stack_trace"], "from in-code config"
-            ):
-                self.stack_trace_level = validated_level
+        if (
+            "INSTANA_STACK_TRACE" not in os.environ
+            and "stack_trace" in global_config
+            and (
+                validated_level := validate_stack_trace_level(
+                    global_config["stack_trace"], "from in-code config"
+                )
+            )
+        ):
+            self.stack_trace_level = validated_level
 
         if (
             "INSTANA_STACK_TRACE_LENGTH" not in os.environ
             and "stack_trace_length" in global_config
-        ):
-            if validated_length := validate_stack_trace_length(
+        ) and (
+            validated_length := validate_stack_trace_length(
                 global_config["stack_trace_length"], "from in-code config"
-            ):
-                self.stack_trace_length = validated_length
+            )
+        ):
+            self.stack_trace_length = validated_length
 
         # Technology-specific overrides from in-code config
         for tech_name, tech_data in config["tracing"].items():
@@ -429,17 +435,19 @@ def _apply_agent_global_stack_trace_config(
         self, global_config: Dict[str, Any]
     ) -> None:
         """Apply global stack trace configuration from agent config."""
-        if "stack-trace" in global_config:
-            if validated_level := validate_stack_trace_level(
+        if "stack-trace" in global_config and (
+            validated_level := validate_stack_trace_level(
                 global_config["stack-trace"], "in agent config"
-            ):
-                self.stack_trace_level = validated_level
+            )
+        ):
+            self.stack_trace_level = validated_level
 
-        if "stack-trace-length" in global_config:
-            if validated_length := validate_stack_trace_length(
+        if "stack-trace-length" in global_config and (
+            validated_length := validate_stack_trace_length(
                 global_config["stack-trace-length"], "in agent config"
-            ):
-                self.stack_trace_length = validated_length
+            )
+        ):
+            self.stack_trace_length = validated_length
 
     def _apply_agent_tech_stack_trace_config(self, tracing: Dict[str, Any]) -> None:
         """Apply technology-specific stack trace configuration from agent config."""

src/instana/util/span_utils.py

@@ -32,9 +32,8 @@ def matches_rule(rule_attributes: List[Any], span_attributes: List[Any]) -> bool
                     rule_matched = True
 
         elif key == "type":
-            if "type" in span_attributes:
-                if span_attributes["type"] in target_values:
-                    rule_matched = True
+            if "type" in span_attributes and span_attributes["type"] in target_values:
+                rule_matched = True
 
         else:
             if key in span_attributes:
@@ -56,18 +55,17 @@ def match_key_filter(span_value: str, rule_value: str, match_type: str) -> bool:
     if span_value is None:
         return False
 
-    if rule_value == "*":
-        return True
-    elif match_type == "strict" and span_value == rule_value:
-        return True
-    elif match_type == "contains" and rule_value in span_value:
-        return True
-    elif match_type == "startswith" and span_value.startswith(rule_value):
-        return True
-    elif match_type == "endswith" and span_value.endswith(rule_value):
-        return True
-
-    return False
+    return bool(
+        rule_value == "*"
+        or match_type == "strict"
+        and span_value == rule_value
+        or match_type == "contains"
+        and rule_value in span_value
+        or match_type == "startswith"
+        and span_value.startswith(rule_value)
+        or match_type == "endswith"
+        and span_value.endswith(rule_value)
+    )
 
 
 def get_span_kind(span_kind: Any) -> str: