Fix linting

Author: majanjua-amzn

aws-opentelemetry-distro/src/amazon/opentelemetry/distro/aws_opentelemetry_configurator.py

@@ -413,14 +413,11 @@ def _customize_sampler(sampler: Sampler) -> Sampler:
 
         try:
             parsed_config = _parse_config_string(config)
-        except Exception as e:
-            _logger.warning("Failed to parse adaptive sampling configuration: %s", str(e))
+        except ValueError as error:
+            _logger.warning("Failed to parse adaptive sampling configuration: %s", str(error))
 
         if parsed_config is not None:
-            try:
-                sampler.set_adaptive_sampling_config(parsed_config)
-            except Exception as e:
-                _logger.warning("Error processing adaptive sampling config: %s", str(e))
+            sampler.set_adaptive_sampling_config(parsed_config)
 
     if not _is_application_signals_enabled():
         return sampler
@@ -937,8 +934,8 @@ def _parse_config_string(config: str) -> Optional[_AWSXRayAdaptiveSamplingConfig
     if path.exists():
         try:
             config = path.read_text(encoding="utf-8")
-        except IOError as e:
-            raise ValueError(f"Failed to read adaptive sampling configuration file: {e}") from e
+        except IOError as err:
+            raise ValueError(f"Failed to read adaptive sampling configuration file: {err}") from err
     elif config.endswith(".yml") or config.endswith(".yaml"):
         raise ValueError("Adaptive sampling configuration file must be a YAML file")
     else:
@@ -958,10 +955,10 @@ def _parse_config_string(config: str) -> Optional[_AWSXRayAdaptiveSamplingConfig
     if version_obj is None:
         raise ValueError("Missing required 'version' field in adaptive sampling configuration")
 
-    version = float(version_obj)
-    if version < 1.0 or version >= 2.0:
+    config_version = float(version_obj)
+    if config_version < 1.0 or config_version >= 2.0:
         raise ValueError(
-            f"Incompatible adaptive sampling config version: {version}. "
+            f"Incompatible adaptive sampling config version: {config_version}. "
             "This version of the AWS X-Ray remote sampler only supports version 1.X."
         )
 
@@ -987,5 +984,5 @@ def _parse_config_string(config: str) -> Optional[_AWSXRayAdaptiveSamplingConfig
         )
 
     return _AWSXRayAdaptiveSamplingConfig(
-        version=version, anomaly_conditions=anomaly_conditions, anomaly_capture_limit=anomaly_capture_limit
+        version=config_version, anomaly_conditions=anomaly_conditions, anomaly_capture_limit=anomaly_capture_limit
     )

aws-opentelemetry-distro/src/amazon/opentelemetry/distro/sampler/_aws_sampling_result.py

@@ -15,13 +15,19 @@ class _AwsSamplingResult(SamplingResult):
     def __init__(
         self,
         decision: Decision,
-        attributes: "Attributes" = {},
+        attributes: "Attributes" = None,
         trace_state: Optional["TraceState"] = None,
         sampling_rule_name: Optional[str] = None,
         has_adaptive_sampling_config: bool = False,
     ):
+        # Define attributes that will be defined by super()
+        self.decision = decision
+        self.trace_state = None
+        self.attributes = None
+
         super().__init__(decision, attributes, trace_state)
 
+        # super will have defined self.attributes by this point
         self.attributes = MappingProxyType(
             {
                 **self.attributes,

aws-opentelemetry-distro/src/amazon/opentelemetry/distro/sampler/_aws_xray_sampling_client.py

@@ -6,7 +6,7 @@
 
 import requests
 
-from amazon.opentelemetry.distro.sampler._sampling_rule import _SamplingRateBoost, _SamplingRule
+from amazon.opentelemetry.distro.sampler._sampling_rule import _SamplingRule
 from amazon.opentelemetry.distro.sampler._sampling_target import _SamplingTargetResponse
 
 _logger = getLogger(__name__)
@@ -58,7 +58,7 @@ def get_sampling_rules(self) -> List[_SamplingRule]:
         return sampling_rules
 
     def get_sampling_targets(
-        self, statistics: List[Dict], boostStatistics: List[Dict] = None
+        self, statistics: List[Dict], boost_statistics: List[Dict] = None
     ) -> _SamplingTargetResponse:
         sampling_targets_response = _SamplingTargetResponse(
             LastRuleModification=None,
@@ -74,7 +74,7 @@ def get_sampling_targets(
                 timeout=20,
                 json={
                     "SamplingStatisticsDocuments": statistics,
-                    "SamplingBoostStatisticsDocuments": boostStatistics,
+                    "SamplingBoostStatisticsDocuments": boost_statistics,
                 },
             )
             if xray_response is None:

aws-opentelemetry-distro/src/amazon/opentelemetry/distro/sampler/_rate_limiting_sampler.py

@@ -36,6 +36,6 @@ def get_description(self) -> str:
         description = (
             "RateLimitingSampler{rate limiting sampling with sampling config of "
             + str(self.__quota)
-            + " req/sec and 0% of additional requests}"
+            + " req/s and 0% of additional requests}"
         )
         return description

aws-opentelemetry-distro/src/amazon/opentelemetry/distro/sampler/_rule_cache.py

@@ -8,11 +8,11 @@
 
 from cachetools import TTLCache
 
-import opentelemetry.baggage as baggage
 from amazon.opentelemetry.distro._aws_attribute_keys import AWS_LOCAL_OPERATION
 from amazon.opentelemetry.distro._aws_span_processing_util import _generate_ingress_operation
 from amazon.opentelemetry.distro.sampler._aws_sampling_result import _AwsSamplingResult
 from amazon.opentelemetry.distro.sampler._aws_xray_adaptive_sampling_config import (
+    _AnomalyConditions,
     _AWSXRayAdaptiveSamplingConfig,
     _UsageType,
 )
@@ -22,6 +22,7 @@
 from amazon.opentelemetry.distro.sampler._sampling_rule import _SamplingRule
 from amazon.opentelemetry.distro.sampler._sampling_rule_applier import _SamplingRuleApplier
 from amazon.opentelemetry.distro.sampler._sampling_target import _SamplingTarget, _SamplingTargetResponse
+from opentelemetry import baggage
 from opentelemetry.context import Context
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import ReadableSpan, StatusCode
@@ -82,9 +83,9 @@ def should_sample(
             _AwsSamplingResult.AWS_XRAY_SAMPLING_RULE_TRACE_STATE_KEY
         )
         if upstream_matched_rule is None:
-            b = baggage.get_all(parent_context)
+            bag = baggage.get_all(parent_context)
             upstream_matched_rule = (
-                b.get(_AwsSamplingResult.AWS_XRAY_SAMPLING_RULE_TRACE_STATE_KEY) if b is not None else None
+                bag.get(_AwsSamplingResult.AWS_XRAY_SAMPLING_RULE_TRACE_STATE_KEY) if bag is not None else None
             )
         result: SamplingResult = None
         for rule_applier in self.__rule_appliers:
@@ -138,6 +139,7 @@ def set_adaptive_sampling_config(self, config: _AWSXRayAdaptiveSamplingConfig) -
             else:
                 self._anomaly_capture_rate_limiter = _RateLimiter(1, 1, self._clock)
 
+    # pylint: disable=too-many-locals
     def adapt_sampling(self, span: ReadableSpan, span_batcher: Callable[[ReadableSpan], None]) -> None:
         if not self._adaptive_sampling_rule_exists and self._adaptive_sampling_config is None:
             return
@@ -203,12 +205,13 @@ def adapt_sampling(self, span: ReadableSpan, span_batcher: Callable[[ReadableSpa
 
         self.__update_trace_usage_cache(trace_id, is_span_captured, is_counted_as_anomaly_for_boost)
 
+    # pylint: disable=too-many-branches
     def __is_anomaly(self, span: ReadableSpan) -> "_AnomalyDetectionResult":
         should_boost_sampling: bool = False
         should_capture_anomaly_span: bool = False
         status_code: int = span.attributes.get(HTTP_STATUS_CODE)
 
-        anomaly_conditions = (
+        anomaly_conditions: List[_AnomalyConditions] = (
             self._adaptive_sampling_config.anomaly_conditions if self._adaptive_sampling_config else None
         )
         # Empty list -> no conditions will apply and we will not do anything
@@ -217,6 +220,8 @@ def __is_anomaly(self, span: ReadableSpan) -> "_AnomalyDetectionResult":
             if operation is None:
                 operation = _generate_ingress_operation(span)
 
+            # It is an iterable, but the current pylint version doesn't recognize it
+            # pylint: disable=not-an-iterable
             for condition in anomaly_conditions:
                 # Skip condition if it would only re-apply action already being taken
                 if (should_boost_sampling and condition.usage == _UsageType.SAMPLING_BOOST) or (

aws-opentelemetry-distro/src/amazon/opentelemetry/distro/sampler/_sampling_rule.py

@@ -32,6 +32,7 @@ def __eq__(self, other: object) -> bool:
 # Disable snake_case naming style so this class can match the sampling rules response from X-Ray
 # pylint: disable=invalid-name
 class _SamplingRule:
+    # pylint: disable=too-many-locals
     def __init__(
         self,
         Attributes: dict = None,

aws-opentelemetry-distro/src/amazon/opentelemetry/distro/sampler/aws_xray_remote_sampler.py

@@ -16,7 +16,7 @@
 from opentelemetry.context import Context
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import ReadableSpan
-from opentelemetry.sdk.trace.export import BatchSpanProcessor, SpanExporter
+from opentelemetry.sdk.trace.export import SpanExporter
 from opentelemetry.sdk.trace.sampling import ParentBased, Sampler, SamplingResult
 from opentelemetry.trace import Link, SpanKind
 from opentelemetry.trace.span import TraceState
@@ -129,7 +129,8 @@ def set_adaptive_sampling_config(self, config: _AWSXRayAdaptiveSamplingConfig) -
         if self.adaptive_sampling_config is not None:
             _logger.warning("Programming bug - Adaptive sampling config is already set")
             return
-        elif self.adaptive_sampling_config is None and config is not None:
+
+        if self.adaptive_sampling_config is None and config is not None:
             self.adaptive_sampling_config = config
             self.__rule_cache.set_adaptive_sampling_config(config)
 

aws-opentelemetry-distro/tests/amazon/opentelemetry/distro/sampler/test_aws_xray_remote_sampler.py

@@ -13,11 +13,9 @@
 from amazon.opentelemetry.distro.sampler._aws_xray_adaptive_sampling_config import _AWSXRayAdaptiveSamplingConfig
 from amazon.opentelemetry.distro.sampler._sampling_rule import _SamplingRule
 from amazon.opentelemetry.distro.sampler.aws_xray_remote_sampler import AwsXRayRemoteSampler
-from opentelemetry.context import Context
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import Tracer, TracerProvider
 from opentelemetry.sdk.trace.sampling import Decision
-from opentelemetry.trace import get_current_span
 
 TEST_DIR = os.path.dirname(os.path.realpath(__file__))
 DATA_DIR = os.path.join(TEST_DIR, "data")

aws-opentelemetry-distro/tests/amazon/opentelemetry/distro/sampler/test_rate_limiting_sampler.py

@@ -86,5 +86,5 @@ def test_get_description(self):
         sampler = _RateLimitingSampler(1, MockClock())
         self.assertEqual(
             sampler.get_description(),
-            "RateLimitingSampler{rate limiting sampling with sampling config of 1 req/sec and 0% of additional requests}",
+            "RateLimitingSampler{rate limiting sampling with sampling config of 1 req/s and 0% of additional requests}",
         )

aws-opentelemetry-distro/tests/amazon/opentelemetry/distro/sampler/test_rule_cache.py

@@ -304,6 +304,7 @@ def test_no_adaptive_sampling_uses_no_space(self):
         readable_span_mock: ReadableSpan = MagicMock()
 
         def stubbed_consumer(span):
+            nonlocal export_counter
             export_counter += 1
 
         rule_cache.adapt_sampling(readable_span_mock, stubbed_consumer)