api-to-dataframe 1.5.2__tar.gz → 2.0.0__tar.gz

{api_to_dataframe-1.5.2 → api_to_dataframe-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: api-to-dataframe
-Version: 1.5.2
+Version: 2.0.0
 Summary: A package to convert API responses to pandas dataframe
 License: MIT
 Author: IvanildoBarauna
@@ -15,7 +15,6 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.8
 Requires-Dist: logging (>=0.4.9.6,<0.5.0.0)
-Requires-Dist: otel-wrapper (>=0.1.1,<0.2.0)
 Requires-Dist: pandas (>=2.2.3,<3.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
 Project-URL: Documentation, https://github.com/IvanildoBarauna/api-to-dataframe/blob/main/README.md

{api_to_dataframe-1.5.2 → api_to_dataframe-2.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "api-to-dataframe"
-version = "1.5.2"
+version = "2.0.0"
 description = "A package to convert API responses to pandas dataframe"
 authors = ["IvanildoBarauna <ivanildo.jnr@outlook.com>"]
 readme = "README.md"
@@ -27,7 +27,6 @@ python = "^3.9"
 pandas = "^2.2.3"
 requests = "^2.32.3"
 logging = "^0.4.9.6"
-otel-wrapper = "^0.1.1"
 
 [tool.poetry.group.dev.dependencies]
 poetry-dynamic-versioning = "^1.3.0"

api_to_dataframe-2.0.0/src/api_to_dataframe/controller/client_builder.py

@@ -0,0 +1,95 @@
+from api_to_dataframe.models.retainer import retry_strategies, Strategies
+from api_to_dataframe.models.get_data import GetData
+from api_to_dataframe.utils.logger import logger
+
+
+class ClientBuilder:
+    def __init__(  # pylint: disable=too-many-positional-arguments,too-many-arguments
+        self,
+        endpoint: str,
+        headers: dict = None,
+        retry_strategy: Strategies = Strategies.NO_RETRY_STRATEGY,
+        retries: int = 3,
+        initial_delay: int = 1,
+        connection_timeout: int = 1,
+    ):
+        """
+        Initializes the ClientBuilder object.
+
+        Args:
+            endpoint (str): The API endpoint to connect to.
+            headers (dict, optional): The headers to use for the API request. Defaults to None.
+            retry_strategy (Strategies, optional): Defaults to Strategies.NO_RETRY_STRATEGY.
+            retries (int): The number of times to retry a failed request. Defaults to 3.
+            initial_delay (int): The delay between retries in seconds. Defaults to 1.
+            connection_timeout (int): The timeout for the connection in seconds. Defaults to 1.
+
+        Raises:
+            ValueError: If endpoint is an empty string.
+            ValueError: If retries is not a non-negative integer.
+            ValueError: If delay is not a non-negative integer.
+            ValueError: If connection_timeout is not a non-negative integer.
+        """
+
+        if headers is None:
+            headers = {}
+        if endpoint == "":
+            error_msg = "endpoint cannot be an empty string"
+            logger.error(error_msg)
+            raise ValueError
+        if not isinstance(retries, int) or retries < 0:
+            error_msg = "retries must be a non-negative integer"
+            logger.error(error_msg)
+            raise ValueError
+        if not isinstance(initial_delay, int) or initial_delay < 0:
+            error_msg = "initial_delay must be a non-negative integer"
+            logger.error(error_msg)
+            raise ValueError
+        if not isinstance(connection_timeout, int) or connection_timeout < 0:
+            error_msg = "connection_timeout must be a non-negative integer"
+            logger.error(error_msg)
+            raise ValueError
+
+        self.endpoint = endpoint
+        self.retry_strategy = retry_strategy
+        self.connection_timeout = connection_timeout
+        self.headers = headers
+        self.retries = retries
+        self.delay = initial_delay
+
+    @retry_strategies
+    def get_api_data(self):
+        """
+        Retrieves data from the API using the defined endpoint and retry strategy.
+
+        This function sends a request to the API using the endpoint, headers, and
+        connection timeout specified in the instance attributes. It uses the
+        defined retry strategy to handle potential failures and retries.
+
+        Returns:
+            dict: The JSON response from the API as a dictionary.
+        """
+        response = GetData.get_response(
+            endpoint=self.endpoint,
+            headers=self.headers,
+            connection_timeout=self.connection_timeout,
+        )
+
+        return response.json()
+
+    @staticmethod
+    def api_to_dataframe(response: dict):
+        """
+        Converts an API response to a DataFrame.
+
+        This function takes a dictionary response from an API,
+        uses the `to_dataframe` function from the `GetData` class
+        to convert it into a DataFrame, and logs the operation as successful.
+
+        Args:
+            response (dict): The dictionary containing the API response.
+
+        Returns:
+            DataFrame: A pandas DataFrame containing the data from the API response.
+        """
+        return GetData.to_dataframe(response)

api_to_dataframe-2.0.0/src/api_to_dataframe/models/get_data.py

@@ -0,0 +1,27 @@
+import requests
+import pandas as pd
+from api_to_dataframe.utils.logger import logger
+
+
+class GetData:
+    @staticmethod
+    def get_response(endpoint: str, headers: dict, connection_timeout: int):
+        # Make the request
+        response = requests.get(endpoint, timeout=connection_timeout, headers=headers)
+
+        # Attempt to raise for status to catch errors
+        response.raise_for_status()
+
+        return response
+
+    @staticmethod
+    def to_dataframe(response):
+        df = pd.DataFrame(response)
+
+        # Check if DataFrame is empty
+        if df.empty:
+            error_msg = "::: DataFrame is empty :::"
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+        return df

api_to_dataframe-2.0.0/src/api_to_dataframe/models/retainer.py

@@ -0,0 +1,39 @@
+import time
+from enum import Enum
+
+from requests.exceptions import RequestException
+from api_to_dataframe.utils.logger import logger
+from api_to_dataframe.utils import Constants
+
+
+class Strategies(Enum):
+    NO_RETRY_STRATEGY = 0
+    LINEAR_RETRY_STRATEGY = 1
+    EXPONENTIAL_RETRY_STRATEGY = 2
+
+
+def retry_strategies(func):
+    def wrapper(*args, **kwargs):  # pylint: disable=inconsistent-return-statements
+        retry_number = 0
+        while retry_number < args[0].retries:
+            try:
+                if retry_number > 0:
+                    logger.info(
+                        f"Trying for the {retry_number} of {Constants.MAX_OF_RETRIES} retries. Using {args[0].retry_strategy}"
+                    )
+                return func(*args, **kwargs)
+            except RequestException as e:
+                retry_number += 1
+
+                if args[0].retry_strategy == Strategies.NO_RETRY_STRATEGY:
+                    raise e
+                if args[0].retry_strategy == Strategies.LINEAR_RETRY_STRATEGY:
+                    time.sleep(args[0].delay)
+                elif args[0].retry_strategy == Strategies.EXPONENTIAL_RETRY_STRATEGY:
+                    time.sleep(args[0].delay * retry_number)
+
+                if retry_number in (args[0].retries, Constants.MAX_OF_RETRIES):
+                    logger.error(f"Failed after {retry_number} retries")
+                    raise e
+
+    return wrapper

{api_to_dataframe-1.5.2 → api_to_dataframe-2.0.0}/src/api_to_dataframe/utils/logger.py

@@ -1,7 +1,5 @@
 import logging
-from otel_wrapper.deps_injector import wrapper_builder
 
-# Configure logging once at the start of your program
 logging.basicConfig(
     encoding="utf-8",
     format="%(asctime)s :: api-to-dataframe[%(levelname)s] :: %(message)s",
@@ -11,6 +9,3 @@ logging.basicConfig(
 
 # Initialize traditional logger
 logger = logging.getLogger("api-to-dataframe")
-
-# Initialize OpenTelemetry wrapper
-telemetry = wrapper_builder("api-to-dataframe")

api_to_dataframe-1.5.2/src/api_to_dataframe/controller/client_builder.py

@@ -1,257 +0,0 @@
-from api_to_dataframe.models.retainer import retry_strategies, Strategies
-from api_to_dataframe.models.get_data import GetData
-from api_to_dataframe.utils.logger import logger, telemetry
-import time
-
-
-class ClientBuilder:
-    def __init__(  # pylint: disable=too-many-positional-arguments,too-many-arguments
-        self,
-        endpoint: str,
-        headers: dict = None,
-        retry_strategy: Strategies = Strategies.NO_RETRY_STRATEGY,
-        retries: int = 3,
-        initial_delay: int = 1,
-        connection_timeout: int = 1,
-    ):
-        """
-        Initializes the ClientBuilder object.
-
-        Args:
-            endpoint (str): The API endpoint to connect to.
-            headers (dict, optional): The headers to use for the API request. Defaults to None.
-            retry_strategy (Strategies, optional): Defaults to Strategies.NO_RETRY_STRATEGY.
-            retries (int): The number of times to retry a failed request. Defaults to 3.
-            initial_delay (int): The delay between retries in seconds. Defaults to 1.
-            connection_timeout (int): The timeout for the connection in seconds. Defaults to 1.
-
-        Raises:
-            ValueError: If endpoint is an empty string.
-            ValueError: If retries is not a non-negative integer.
-            ValueError: If delay is not a non-negative integer.
-            ValueError: If connection_timeout is not a non-negative integer.
-        """
-
-        if headers is None:
-            headers = {}
-        if endpoint == "":
-            error_msg = "endpoint cannot be an empty string"
-            logger.error(error_msg)
-            telemetry.logs().new_log(
-                msg=error_msg,
-                tags={"component": "ClientBuilder", "method": "__init__"},
-                level=40  # ERROR level
-            )
-            raise ValueError
-        if not isinstance(retries, int) or retries < 0:
-            error_msg = "retries must be a non-negative integer"
-            logger.error(error_msg)
-            telemetry.logs().new_log(
-                msg=error_msg,
-                tags={"component": "ClientBuilder", "method": "__init__"},
-                level=40  # ERROR level
-            )
-            raise ValueError
-        if not isinstance(initial_delay, int) or initial_delay < 0:
-            error_msg = "initial_delay must be a non-negative integer"
-            logger.error(error_msg)
-            telemetry.logs().new_log(
-                msg=error_msg,
-                tags={"component": "ClientBuilder", "method": "__init__"},
-                level=40  # ERROR level
-            )
-            raise ValueError
-        if not isinstance(connection_timeout, int) or connection_timeout < 0:
-            error_msg = "connection_timeout must be a non-negative integer"
-            logger.error(error_msg)
-            telemetry.logs().new_log(
-                msg=error_msg,
-                tags={"component": "ClientBuilder", "method": "__init__"},
-                level=40  # ERROR level
-            )
-            raise ValueError
-
-        self.endpoint = endpoint
-        self.retry_strategy = retry_strategy
-        self.connection_timeout = connection_timeout
-        self.headers = headers
-        self.retries = retries
-        self.delay = initial_delay
-
-        # Record client initialization metric
-        telemetry.metrics().metric_increment(
-            name="client.initialization",
-            tags={
-                "endpoint": endpoint,
-                "retry_strategy": retry_strategy.name,
-                "connection_timeout": str(connection_timeout)
-            }
-        )
-
-        # Log initialization
-        telemetry.logs().new_log(
-            msg=f"ClientBuilder initialized with endpoint {endpoint}",
-            tags={
-                "endpoint": endpoint,
-                "retry_strategy": retry_strategy.name,
-                "connection_timeout": str(connection_timeout),
-                "component": "ClientBuilder"
-            },
-            level=20  # INFO level
-        )
-
-    @retry_strategies
-    def get_api_data(self):
-        """
-        Retrieves data from the API using the defined endpoint and retry strategy.
-
-        This function sends a request to the API using the endpoint, headers, and
-        connection timeout specified in the instance attributes. It uses the
-        defined retry strategy to handle potential failures and retries.
-
-        Returns:
-            dict: The JSON response from the API as a dictionary.
-        """
-        # Use the telemetry spans with new API
-        span = telemetry.traces().new_span("get_api_data")
-        try:
-            # Add span attributes
-            span.set_attribute("endpoint", self.endpoint)
-            span.set_attribute("retry_strategy", self.retry_strategy.name)
-            span.set_attribute("connection_timeout", self.connection_timeout)
-
-            # Log the API request
-            telemetry.logs().new_log(
-                msg=f"Making API request to {self.endpoint}",
-                tags={
-                    "endpoint": self.endpoint,
-                    "component": "ClientBuilder",
-                    "method": "get_api_data"
-                },
-                level=20  # INFO level
-            )
-
-            # Record the start time for response time measurement
-            start_time = time.time()
-
-            # Make the API request
-            response = GetData.get_response(
-                endpoint=self.endpoint,
-                headers=self.headers,
-                connection_timeout=self.connection_timeout,
-            )
-
-            # Calculate response time
-            response_time = time.time() - start_time
-
-            # Record response time as histogram
-            telemetry.metrics().record_histogram(
-                name="api.response_time",
-                tags={"endpoint": self.endpoint},
-                value=response_time
-            )
-
-            # Record successful request metric
-            telemetry.metrics().metric_increment(
-                name="api.request.success",
-                tags={"endpoint": self.endpoint}
-            )
-
-            # Log success
-            telemetry.logs().new_log(
-                msg=f"API request to {self.endpoint} successful",
-                tags={
-                    "endpoint": self.endpoint,
-                    "response_status": response.status_code,
-                    "response_time": response_time,
-                    "component": "ClientBuilder",
-                    "method": "get_api_data"
-                },
-                level=20  # INFO level
-            )
-
-            return response.json()
-        finally:
-            span.end()
-
-    @staticmethod
-    def api_to_dataframe(response: dict):
-        """
-        Converts an API response to a DataFrame.
-
-        This function takes a dictionary response from an API,
-        uses the `to_dataframe` function from the `GetData` class
-        to convert it into a DataFrame, and logs the operation as successful.
-
-        Args:
-            response (dict): The dictionary containing the API response.
-
-        Returns:
-            DataFrame: A pandas DataFrame containing the data from the API response.
-        """
-        # Use telemetry with new API
-        span = telemetry.traces().new_span("api_to_dataframe")
-        try:
-            response_size = len(response) if isinstance(response, list) else 1
-            span.set_attribute("response_size", response_size)
-
-            # Log conversion start
-            telemetry.logs().new_log(
-                msg="Converting API response to DataFrame",
-                tags={
-                    "response_size": response_size,
-                    "response_type": type(response).__name__,
-                    "component": "ClientBuilder",
-                    "method": "api_to_dataframe"
-                },
-                level=20  # INFO level
-            )
-
-            try:
-                # Convert to dataframe
-                df = GetData.to_dataframe(response)
-
-                # Record metrics
-                telemetry.metrics().metric_increment(
-                    name="dataframe.conversion.success",
-                    tags={"size": len(df)}
-                )
-
-                # Log success
-                telemetry.logs().new_log(
-                    msg="Successfully converted API response to DataFrame",
-                    tags={
-                        "dataframe_rows": len(df),
-                        "dataframe_columns": len(df.columns),
-                        "component": "ClientBuilder",
-                        "method": "api_to_dataframe"
-                    },
-                    level=20  # INFO level
-                )
-
-                return df
-
-            except Exception as e:
-                # Record failure metric
-                telemetry.metrics().metric_increment(
-                    name="dataframe.conversion.failure",
-                    tags={"error_type": type(e).__name__}
-                )
-
-                # Log error
-                error_msg = f"Failed to convert API response to DataFrame: {str(e)}"
-                telemetry.logs().new_log(
-                    msg=error_msg,
-                    tags={
-                        "error": str(e),
-                        "error_type": type(e).__name__,
-                        "component": "ClientBuilder",
-                        "method": "api_to_dataframe"
-                    },
-                    level=40  # ERROR level
-                )
-
-                # Re-raise the exception
-                raise
-        finally:
-            span.end()

api_to_dataframe-1.5.2/src/api_to_dataframe/models/get_data.py

@@ -1,221 +0,0 @@
-import requests
-import pandas as pd
-from api_to_dataframe.utils.logger import logger, telemetry
-
-
-class GetData:
-    @staticmethod
-    def get_response(endpoint: str, headers: dict, connection_timeout: int):
-        # Start a span for the API request
-        span = telemetry.traces().new_span("http_request")
-        try:
-            span.set_attribute("http.url", endpoint)
-            span.set_attribute("http.method", "GET")
-            span.set_attribute("http.timeout", connection_timeout)
-
-            # Log the request
-            telemetry.logs().new_log(
-                msg=f"Sending HTTP GET request to {endpoint}",
-                tags={
-                    "endpoint": endpoint,
-                    "timeout": connection_timeout,
-                    "component": "GetData",
-                    "method": "get_response"
-                },
-                level=20  # INFO level
-            )
-
-            try:
-                # Make the request
-                response = requests.get(endpoint, timeout=connection_timeout, headers=headers)
-
-                # Set response attributes on span
-                span.set_attribute("http.status_code", response.status_code)
-                span.set_attribute("http.response_content_length", len(response.content))
-
-                # Attempt to raise for status to catch errors
-                response.raise_for_status()
-
-                # Log successful response
-                telemetry.logs().new_log(
-                    msg=f"Received HTTP {response.status_code} response from {endpoint}",
-                    tags={
-                        "endpoint": endpoint,
-                        "status_code": response.status_code,
-                        "response_size": len(response.content),
-                        "component": "GetData",
-                        "method": "get_response"
-                    },
-                    level=20  # INFO level
-                )
-
-                # Record successful request metric
-                telemetry.metrics().metric_increment(
-                    name="http.request.success",
-                    tags={
-                        "endpoint": endpoint,
-                        "status_code": response.status_code
-                    }
-                )
-
-                return response
-
-            except requests.exceptions.RequestException as e:
-                # Record the exception on the span
-                span.record_exception(e)
-                span.set_attribute("error", True)
-                span.set_attribute("error.type", type(e).__name__)
-                span.set_attribute("error.message", str(e))
-
-                # Log the error
-                telemetry.logs().new_log(
-                    msg=f"HTTP request failed: {str(e)}",
-                    tags={
-                        "endpoint": endpoint,
-                        "error": str(e),
-                        "error_type": type(e).__name__,
-                        "component": "GetData",
-                        "method": "get_response"
-                    },
-                    level=40  # ERROR level
-                )
-
-                # Record failure metric
-                telemetry.metrics().metric_increment(
-                    name="http.request.failure",
-                    tags={
-                        "endpoint": endpoint,
-                        "error_type": type(e).__name__
-                    }
-                )
-
-                # Re-raise the exception
-                raise
-        finally:
-            span.end()
-
-    @staticmethod
-    def to_dataframe(response):
-        # Start a span for dataframe conversion
-        span = telemetry.traces().new_span("convert_to_dataframe")
-        try:
-            # Set attributes about the data
-            data_size = len(response) if isinstance(response, list) else 1
-            span.set_attribute("data.size", data_size)
-            span.set_attribute("data.type", type(response).__name__)
-
-            # Log conversion attempt
-            telemetry.logs().new_log(
-                msg="Converting data to DataFrame",
-                tags={
-                    "data_size": data_size,
-                    "data_type": type(response).__name__,
-                    "component": "GetData",
-                    "method": "to_dataframe"
-                },
-                level=20  # INFO level
-            )
-
-            try:
-                # Convert to DataFrame
-                df = pd.DataFrame(response)
-
-                # Check if DataFrame is empty
-                if df.empty:
-                    error_msg = "::: DataFrame is empty :::"
-                    logger.error(error_msg)
-
-                    # Log the error with OpenTelemetry
-                    telemetry.logs().new_log(
-                        msg=error_msg,
-                        tags={
-                            "data_size": data_size,
-                            "data_type": type(response).__name__,
-                            "component": "GetData",
-                            "method": "to_dataframe"
-                        },
-                        level=40  # ERROR level
-                    )
-
-                    # Record empty DataFrame metric
-                    telemetry.metrics().metric_increment(
-                        name="dataframe.empty",
-                        tags={"data_type": type(response).__name__}
-                    )
-
-                    # Set span as error
-                    span.set_attribute("error", True)
-                    span.set_attribute("error.type", "ValueError")
-                    span.set_attribute("error.message", error_msg)
-
-                    raise ValueError(error_msg)
-
-                # Log success
-                telemetry.logs().new_log(
-                    msg="Successfully converted data to DataFrame",
-                    tags={
-                        "rows": len(df),
-                        "columns": len(df.columns),
-                        "component": "GetData",
-                        "method": "to_dataframe"
-                    },
-                    level=20  # INFO level
-                )
-
-                # Record dataframe metrics
-                telemetry.metrics().record_gauge(
-                    name="dataframe.rows",
-                    tags={"data_type": type(response).__name__},
-                    value=float(len(df))
-                )
-
-                telemetry.metrics().record_gauge(
-                    name="dataframe.columns",
-                    tags={"data_type": type(response).__name__},
-                    value=float(len(df.columns))
-                )
-
-                # Set additional span attributes
-                span.set_attribute("dataframe.rows", len(df))
-                span.set_attribute("dataframe.columns", len(df.columns))
-
-                return df
-
-            except ValueError:
-                # Re-raise ValueErrors (like empty DataFrame)
-                raise
-
-            except Exception as err:
-                # Log the error
-                error_msg = f"Invalid response for transform in dataframe: {err}"
-                logger.error(error_msg)
-
-                # Log with OpenTelemetry
-                telemetry.logs().new_log(
-                    msg=error_msg,
-                    tags={
-                        "error": str(err),
-                        "error_type": type(err).__name__,
-                        "data_type": type(response).__name__,
-                        "component": "GetData",
-                        "method": "to_dataframe"
-                    },
-                    level=40  # ERROR level
-                )
-
-                # Record conversion failure metric
-                telemetry.metrics().metric_increment(
-                    name="dataframe.conversion.error",
-                    tags={"error_type": type(err).__name__}
-                )
-
-                # Record the exception on the span
-                span.record_exception(err)
-                span.set_attribute("error", True)
-                span.set_attribute("error.type", type(err).__name__)
-                span.set_attribute("error.message", str(err))
-
-                # Raise TypeError with original error as cause
-                raise TypeError(error_msg) from err
-        finally:
-            span.end()

api_to_dataframe-1.5.2/src/api_to_dataframe/models/retainer.py

@@ -1,191 +0,0 @@
-import time
-from enum import Enum
-
-from requests.exceptions import RequestException
-from api_to_dataframe.utils.logger import logger, telemetry
-from api_to_dataframe.utils import Constants
-
-
-class Strategies(Enum):
-    NO_RETRY_STRATEGY = 0
-    LINEAR_RETRY_STRATEGY = 1
-    EXPONENTIAL_RETRY_STRATEGY = 2
-
-
-def retry_strategies(func):
-    def wrapper(*args, **kwargs):  # pylint: disable=inconsistent-return-statements
-        retry_number = 0
-
-        # Get the endpoint for better observability context
-        endpoint = args[0].endpoint if hasattr(args[0], 'endpoint') else 'unknown'
-
-        # Start a span for this entire retry operation
-        span = telemetry.traces().new_span("retry_operation")
-        try:
-            span.set_attribute("endpoint", endpoint)
-            span.set_attribute("retry_strategy", args[0].retry_strategy.name)
-            span.set_attribute("max_retries", args[0].retries)
-
-            while retry_number < args[0].retries:
-                try:
-                    # Log retry attempt if not the first attempt
-                    if retry_number > 0:
-                        # Log using traditional logger
-                        logger.info(f"Trying for the {retry_number} of {Constants.MAX_OF_RETRIES} retries. Using {args[0].retry_strategy}")
-
-                        # Log using OpenTelemetry
-                        telemetry.logs().new_log(
-                            msg=f"Retry attempt {retry_number} of {args[0].retries}",
-                            tags={
-                                "endpoint": endpoint,
-                                "retry_number": retry_number,
-                                "max_retries": args[0].retries,
-                                "retry_strategy": args[0].retry_strategy.name,
-                                "component": "RetryStrategy"
-                            },
-                            level=20  # INFO level
-                        )
-
-                        # Record retry metric
-                        telemetry.metrics().metric_increment(
-                            name="api.request.retry",
-                            tags={
-                                "endpoint": endpoint,
-                                "retry_strategy": args[0].retry_strategy.name
-                            }
-                        )
-
-                        # Update span with current retry count
-                        span.set_attribute("current_retry", retry_number)
-
-                    # Execute the wrapped function
-                    result = func(*args, **kwargs)
-
-                    # If we got here, it succeeded - record success metric after retries
-                    if retry_number > 0:
-                        telemetry.metrics().metric_increment(
-                            name="api.request.retry.success",
-                            tags={
-                                "endpoint": endpoint,
-                                "retry_count": retry_number,
-                                "retry_strategy": args[0].retry_strategy.name
-                            }
-                        )
-
-                        telemetry.logs().new_log(
-                            msg=f"Request succeeded after {retry_number} retries",
-                            tags={
-                                "endpoint": endpoint,
-                                "retry_count": retry_number,
-                                "retry_strategy": args[0].retry_strategy.name,
-                                "component": "RetryStrategy"
-                            },
-                            level=20  # INFO level
-                        )
-
-                    return result
-
-                except RequestException as e:
-                    retry_number += 1
-
-                    # Record exception in the span
-                    span.record_exception(e)
-                    span.set_attribute("failed_attempt", retry_number)
-
-                    # Handle different retry strategies
-                    if args[0].retry_strategy == Strategies.NO_RETRY_STRATEGY:
-                        # Log failure with OpenTelemetry
-                        telemetry.logs().new_log(
-                            msg=f"Request failed with {type(e).__name__}, no retry strategy configured",
-                            tags={
-                                "endpoint": endpoint,
-                                "error": str(e),
-                                "error_type": type(e).__name__,
-                                "component": "RetryStrategy"
-                            },
-                            level=40  # ERROR level
-                        )
-
-                        # Record failure metric
-                        telemetry.metrics().metric_increment(
-                            name="api.request.failure",
-                            tags={
-                                "endpoint": endpoint,
-                                "error_type": type(e).__name__,
-                                "retry_strategy": "none"
-                            }
-                        )
-
-                        raise e
-
-                    # Apply delay based on strategy
-                    if args[0].retry_strategy == Strategies.LINEAR_RETRY_STRATEGY:
-                        delay = args[0].delay
-                        strategy_name = "linear"
-                    elif args[0].retry_strategy == Strategies.EXPONENTIAL_RETRY_STRATEGY:
-                        delay = args[0].delay * retry_number
-                        strategy_name = "exponential"
-
-                    # Log retry delay
-                    telemetry.logs().new_log(
-                        msg=f"Request failed, retrying in {delay}s (strategy: {strategy_name})",
-                        tags={
-                            "endpoint": endpoint,
-                            "retry_count": retry_number,
-                            "delay": delay,
-                            "strategy": strategy_name,
-                            "error": str(e),
-                            "error_type": type(e).__name__,
-                            "component": "RetryStrategy"
-                        },
-                        level=30  # WARNING level
-                    )
-
-                    # Record the delay time in metrics
-                    telemetry.metrics().record_gauge(
-                        name="api.retry.delay",
-                        tags={
-                            "endpoint": endpoint,
-                            "retry_count": retry_number,
-                            "strategy": strategy_name
-                        },
-                        value=float(delay)
-                    )
-
-                    # Sleep for the calculated delay
-                    time.sleep(delay)
-
-                    # Check if we've reached max retries
-                    if retry_number in (args[0].retries, Constants.MAX_OF_RETRIES):
-                        # Log final failure
-                        error_msg = f"Failed after {retry_number} retries"
-                        logger.error(error_msg)
-
-                        telemetry.logs().new_log(
-                            msg=error_msg,
-                            tags={
-                                "endpoint": endpoint,
-                                "retry_count": retry_number,
-                                "max_retries": args[0].retries,
-                                "error": str(e),
-                                "error_type": type(e).__name__,
-                                "component": "RetryStrategy"
-                            },
-                            level=40  # ERROR level
-                        )
-
-                        # Record final failure metric
-                        telemetry.metrics().metric_increment(
-                            name="api.request.retry.exhausted",
-                            tags={
-                                "endpoint": endpoint,
-                                "retry_strategy": args[0].retry_strategy.name,
-                                "error_type": type(e).__name__
-                            }
-                        )
-
-                        raise e
-        finally:
-            span.end()
-
-    return wrapper