fk_util_tools 0.1.14__tar.gz

fk_util_tools-0.1.14/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Finkargo Tech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fk_util_tools-0.1.14/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.3
+Name: fk_util_tools
+Version: 0.1.14
+Summary: Herramientas de utilidad o funciones comunes para los proyectos de FK.
+License: MIT
+Author: Steven Santacruz Garcia
+Author-email: stevengarcia1118@gmail.com
+Requires-Python: >=3.7,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: boto3
+Requires-Dist: opentelemetry-api
+Requires-Dist: opentelemetry-exporter-jaeger
+Requires-Dist: opentelemetry-exporter-otlp
+Requires-Dist: opentelemetry-instrumentation-django
+Requires-Dist: opentelemetry-instrumentation-fastapi
+Requires-Dist: opentelemetry-instrumentation-flask
+Requires-Dist: opentelemetry-instrumentation-psycopg2
+Requires-Dist: opentelemetry-instrumentation-requests
+Requires-Dist: opentelemetry-instrumentation-sqlalchemy
+Requires-Dist: opentelemetry-sdk
+Requires-Dist: psycopg2-binary
+Requires-Dist: starlette
+Project-URL: Homepage, https://gitlab.com/f3315/team-back-end/cross/packages/package_utils

fk_util_tools-0.1.14/fk_utils/__init__.py

@@ -0,0 +1,3 @@
+from . import config
+
+SETTINGS = config.Config()

fk_util_tools-0.1.14/fk_utils/cache/redis.py

@@ -0,0 +1,85 @@
+import base64
+import json
+import redis
+import threading
+from typing import Any, Dict, List, Optional, Union
+
+
+class CacheService:
+    _instance = None
+    _lock = threading.Lock()
+
+    def __new__(cls, redis_url: str):
+        if not cls._instance:
+            with cls._lock:
+                if not cls._instance:
+                    cls._instance = super(CacheService, cls).__new__(cls)
+                    cls._instance.__init_instance__(redis_url)
+        return cls._instance
+
+    def __init_instance__(self, redis_url: str):
+        """ Actual initialization of the singleton instance """
+        self.redis_url = redis_url
+        self.__connect__()
+
+    def __connect__(self):
+        """ Establishes the connection with Redis and handles connection errors """
+        try:
+            print(f"Connecting to Redis at {self.redis_url}...")
+            self._cache = redis.Redis.from_url(self.redis_url, decode_responses=True)
+            self._cache.ping()
+        except redis.ConnectionError as e:
+            print(f"Error de conexión a Redis: {e}")
+            self._cache = None
+
+    def _ensure_connection(self):
+        """ Reconnects if necessary """
+        if not self._cache or not self._cache.ping():
+            print("Reconnecting to Redis...")
+            self.__connect__()
+
+    def add(
+        self, key: str, row: Union[List[Any], Dict[str, Any]], expiration_time: Optional[int] = None
+    ):
+        assert isinstance(key, str), "Only str keys are supported!"
+        assert isinstance(row, (list, dict)), "Only dict or list objects are supported!"
+
+        self._ensure_connection()
+        if not self._cache:
+            print("Could not establish connection with Redis.")
+            return
+
+        raw = {
+            "content": base64.b64encode(json.dumps(row).encode("ascii")).decode("ascii")
+        }
+        self._cache.hset(key, mapping=raw)
+        if expiration_time:
+            self._cache.expire(key, expiration_time)
+
+    def get(self, key: str) -> Optional[Union[List[Any], Dict[str, Any]]]:
+        assert isinstance(key, str), "Only str keys are supported!"
+
+        self._ensure_connection()
+        if not self._cache:
+            print("Could not establish connection with Redis.")
+            return None
+
+        row = self._cache.hgetall(key)
+        if not row:
+            return None
+
+        content = row.get("content")
+        if content is None:
+            return None
+        return json.loads(base64.b64decode(content).decode("ascii"))
+
+    def delete(self, key: str):
+        assert isinstance(key, str), "Only str keys are supported!"
+
+        self._ensure_connection()
+        if not self._cache:
+            print("Could not establish connection with Redis.")
+            return
+
+        if self._cache.exists(key):
+            self._cache.delete(key)

fk_util_tools-0.1.14/fk_utils/config.py

@@ -0,0 +1,24 @@
+import os
+
+
+class Config:
+    def __init__(self):
+        # Environment
+        self.DD_ENV = os.environ.get('DD_ENV', 'localhost')
+        self.DEBUG_UTILS = os.environ.get('DEBUG_UTILS', False)
+        self.REPOSITORY = os.environ.get('REPOSITORY', 'msa_repository')
+        self.TYPE_DEPLOY = os.environ.get('TYPE_DEPLOY', 'api')
+
+        # AWS
+        self.AWS_PROFILE_NAME = os.environ.get('AWS_PROFILE_NAME', 'default')
+        self.AWS_REGION_NAME = os.environ.get('AWS_REGION_NAME', 'us-east-1')
+        self.SECRET_NAME = os.environ.get('SECRET_NAME', 'api/testing/ms-communicator')
+
+        # Opentelemtry
+        self.OTLP_HOST = os.environ.get('OTLP_HOST', 'localhost')
+        self.OTLP_PORT = os.environ.get('OTLP_PORT', '0000')
+        self.OTLP_NAME = os.environ.get('OTLP_NAME', 'ms-localhost')
+
+        # DataDog
+        self.DD_HOST = os.environ.get('DD_HOST', 'localhost')
+        self.DD_PORT = os.environ.get('DD_PORT', '8126')

fk_util_tools-0.1.14/fk_utils/envs/aws/parameters.py

@@ -0,0 +1,41 @@
+import boto3
+import os
+import logging
+from typing import Optional
+from fk_utils import SETTINGS
+
+# Configuración del logger
+logging.basicConfig(level=logging.ERROR)
+logger = logging.getLogger(__name__)
+
+# Crear clientes de Boto3 fuera de las funciones
+ssm_client = boto3.client('ssm', region_name=SETTINGS.AWS_REGION_NAME)
+
+
+def get_parameter(param: str, param_type: str) -> Optional[str]:
+    """
+    Obtiene un parámetro de AWS Systems Manager Parameter Store.
+
+    Args:
+        param (str): Nombre del parámetro.
+        param_type (str): Tipo de parámetro (static, global, static_env, default).
+
+    Returns:
+        str: Valor del parámetro o 'None' si hay un error.
+    """
+    try:
+        param_mappings = {
+            'static': f"/ecs/{SETTINGS.REPOSITORY}_{SETTINGS.TYPE_DEPLOY}/{param}",
+            'global': f"/ecs/global/{param}",
+            'static_env': f"/ecs/{SETTINGS.DD_ENV}/{param}",
+            'default': f"/ecs/{SETTINGS.DD_ENV}/{SETTINGS.REPOSITORY}_{SETTINGS.TYPE_DEPLOY}/{param}"
+        }
+
+        param_name = param_mappings.get(param_type, param_mappings['default'])
+
+        response = ssm_client.get_parameter(Name=param_name, WithDecryption=True)
+        return response['Parameter']['Value']
+    except Exception as e:
+        logger.error(f'Error al obtener el parámetro en AWS: {str(e)}')
+
+    return os.environ.get(param, 'None')

fk_util_tools-0.1.14/fk_utils/envs/aws/secrets.py

@@ -0,0 +1,31 @@
+import boto3
+import json
+import logging
+from typing import Optional
+from fk_utils import SETTINGS
+
+# Configuración del logger
+logging.basicConfig(level=logging.ERROR)
+logger = logging.getLogger(__name__)
+
+# Crear clientes de Boto3 fuera de las funciones
+secrets_manager_client = boto3.client('secretsmanager', region_name=SETTINGS.AWS_REGION_NAME)
+
+
+def get_secret_key() -> Optional[dict]:
+    """
+    Obtiene la clave secreta almacenada en AWS Secrets Manager.
+
+    Returns:
+        dict or None: Diccionario con la clave secreta o None si hay un error.
+    """
+    try:
+        response = secrets_manager_client.get_secret_value(SecretId=SETTINGS.SECRET_NAME)
+        secret_value = response.get('SecretString')
+
+        if secret_value:
+            return json.loads(secret_value)
+    except Exception as e:
+        logger.error(f'Error al obtener el secreto: {str(e)}')
+
+    return None

fk_util_tools-0.1.14/fk_utils/exceptions/custom_http_exception.py

@@ -0,0 +1,12 @@
+from fastapi import HTTPException
+from enum import Enum
+from typing import TypeVar, Optional
+
+T = TypeVar("T", bound=Enum)
+
+
+class CustomHTTPException(HTTPException):
+    def __init__(self, error_code: T, detail: Optional[str] = None):
+        super().__init__(status_code=getattr(error_code, "status_code", 500),
+                         detail=detail or getattr(error_code, "detail", "Unknown error"))
+        self.error_code = error_code

fk_util_tools-0.1.14/fk_utils/exceptions/custom_http_exception.pyi

@@ -0,0 +1,8 @@
+from fastapi import HTTPException
+from enum import Enum
+from typing import TypeVar, Optional
+
+T = TypeVar("T", bound=Enum)
+
+class CustomHTTPException(HTTPException):
+    def __init__(self, error_code: T, detail: Optional[str] = None) -> None: ...

fk_util_tools-0.1.14/fk_utils/logging/fastapi/logging.py

@@ -0,0 +1,56 @@
+import logging
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
+from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
+from opentelemetry.instrumentation.requests import RequestsInstrumentor
+
+from fk_utils import SETTINGS
+
+# Configurar logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def configure_tracer():
+    try:
+        # Configurar el proveedor de trazas
+        trace.set_tracer_provider(TracerProvider(
+            resource=Resource.create({"service.name": SETTINGS.OTLP_NAME})
+        ))
+
+        # Configurar el exportador OTLP
+        otlp_exporter = OTLPSpanExporter(
+            endpoint=f"{SETTINGS.OTLP_HOST}:{SETTINGS.OTLP_PORT}",
+            insecure=True
+        )
+
+        # Añadir el procesador de spans
+        trace.get_tracer_provider().add_span_processor(
+            BatchSpanProcessor(otlp_exporter)
+        )
+
+        logger.info("OpenTelemetry tracer configurado correctamente.")
+
+    except Exception as e:
+        logger.error(f"Error al configurar el tracer de OpenTelemetry: {e}")
+
+
+def instrument_app(app):
+    try:
+        # Instrumentar FastAPI
+        FastAPIInstrumentor.instrument_app(app)
+
+        # Instrumentar SQLAlchemy
+        SQLAlchemyInstrumentor().instrument()
+
+        # Instrumentar Requests
+        RequestsInstrumentor().instrument()
+
+        logger.info("Aplicación instrumentada correctamente con OpenTelemetry.")
+
+    except Exception as e:
+        logger.error(f"Error al instrumentar la aplicación: {e}")

fk_util_tools-0.1.14/fk_utils/middlewares/django/sql_middleware.py

@@ -0,0 +1,60 @@
+import os
+import struct
+import fcntl
+import termios
+from django.db import connection
+from django.conf import settings
+
+
+def terminal_width():
+    """
+    Function to compute the terminal width.
+    """
+    width = 0
+    try:
+        s = struct.pack('HHHH', 0, 0, 0, 0)
+        x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
+        width = struct.unpack('HHHH', x)[1]
+    except (struct.error, fcntl.error, termios.error) as e:
+        print(f"Error computing terminal width: {e}")
+
+    if width <= 0:
+        try:
+            width = int(os.environ['COLUMNS'])
+        except (KeyError, ValueError) as e:
+            print(f"Error getting terminal width from environment: {e}")
+
+    return width if width > 0 else 80
+
+
+def SqlPrintingMiddleware(get_response):
+    """
+    Middleware to print SQL queries in the terminal during a request in debug mode.
+    """
+    def middleware(request):
+        response = get_response(request)
+
+        if not settings.DEBUG or not connection.queries:
+            return response
+
+        indentation = 2
+        print(f"\n\n{' ' * indentation}\033[1;35m[SQL Queries for]\033[1;34m {request.path_info}\033[0m\n")
+        width = terminal_width()
+        total_time = 0.0
+
+        for query in connection.queries:
+            nice_sql = query['sql'].replace('"', '').replace(',', ', ')
+            sql = f"\033[1;31m[{query['time']}]\033[0m {nice_sql}"
+            total_time += float(query['time'])
+
+            while len(sql) > width - indentation:
+                print(f"{' ' * indentation}{sql[:width - indentation]}")
+                sql = sql[width - indentation:]
+            print(f"{' ' * indentation}{sql}\n")
+
+        print(f"{' ' * indentation}\033[1;32m[TOTAL TIME: {total_time} seconds]\033[0m")
+        print(f"{' ' * indentation}\033[1;32m[TOTAL QUERIES: {len(connection.queries)}]\033[0m")
+
+        return response
+
+    return middleware

fk_util_tools-0.1.14/fk_utils/middlewares/fastapi/error_middleware.py

@@ -0,0 +1,128 @@
+import traceback
+from typing import Callable, Awaitable, Type, Any
+from starlette.middleware.base import BaseHTTPMiddleware
+from fastapi.exceptions import RequestValidationError
+from starlette.exceptions import HTTPException as StarletteHTTPException
+from fastapi.responses import JSONResponse
+from fk_utils.exceptions.custom_http_exception import CustomHTTPException
+from fastapi import Request, Response
+from fk_utils.middlewares.fastapi.i18n import _
+import uuid
+import logging
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+
+class ErrorCode(Enum):
+    VALIDATION_ERROR = (
+        "MAIN-VAL-001",
+        "Validation Error",
+        422,
+        "The input data is invalid.",
+    )
+    RESOURCE_NOT_FOUND = (
+        "MAIN-VAL-002",
+        "Resource Not Found",
+        404,
+        "The requested resource does not exist.",
+    )
+    SYSTEM_ERROR = (
+        "MAIN-SYS-001",
+        "System Error",
+        500,
+        "An unexpected error occurred.",
+    )
+
+    def __init__(self, error_code: str, title: str, status_code: int, detail: str):
+        self.error_code = error_code
+        self.title = title
+        self.status_code = status_code
+        self.detail = detail
+
+
+class ErrorMiddleware(BaseHTTPMiddleware):
+    def __init__(self, app: Callable, error_enum: Type[ErrorCode], **kwargs: Any) -> None:
+        """
+        Middleware to handle global errors in the application.
+
+        :param app: FastAPI application.
+        :param error_enum: Enumeration of error codes.
+        """
+        super().__init__(app, **kwargs)
+        self.error_enum = error_enum
+
+    async def dispatch(self, request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
+        try:
+            response = await call_next(request)
+            return response
+        except CustomHTTPException as custom_exc:
+            return self.build_error_response(
+                error_code=custom_exc.error_code,
+                detail=custom_exc.detail,
+                request=request,
+            )
+        except RequestValidationError as validation_exc:
+            user_friendly_detail = self.format_validation_errors(validation_exc, request)
+            return self.build_error_response(
+                error_code=self.error_enum.VALIDATION_ERROR,
+                detail=user_friendly_detail,
+                request=request,
+            )
+        except StarletteHTTPException as http_exc:
+            error_code = (
+                self.error_enum.RESOURCE_NOT_FOUND
+                if http_exc.status_code == 404
+                else self.error_enum.VALIDATION_ERROR
+            )
+            return self.build_error_response(
+                error_code=error_code,
+                detail=str(http_exc.detail),
+                request=request,
+            )
+        except Exception:
+            return self.build_error_response(
+                error_code=self.error_enum.SYSTEM_ERROR,
+                detail="An unexpected error occurred.",
+                request=request,
+            )
+
+    def build_error_response(self, error_code: ErrorCode, detail: str, request: Request) -> JSONResponse:
+        """
+        Builds a JSON response for errors.
+
+        :param error_code: Error code.
+        :param detail: Error detail.
+        :param request: HTTP request.
+        :return: JSON response with the formatted error.
+        """
+        instance_id = str(uuid.uuid4())
+        translated_detail = _(detail, request) if isinstance(detail, str) else detail
+        logger.error(
+            f"Error: {error_code.error_code} - {error_code.title} - {translated_detail} - Instance: {instance_id} - Traceback: {traceback.format_exc()}"
+        )
+        return JSONResponse(
+            status_code=error_code.status_code,
+            content={
+                "error_code": error_code.error_code,
+                "title": _(error_code.title, request),
+                "status": error_code.status_code,
+                "detail": translated_detail,
+                "instance": instance_id,
+            },
+        )
+
+    def format_validation_errors(self, exc: RequestValidationError, request: Request) -> str:
+        error_messages = []
+        for error in exc.errors():
+            loc = "".join(map(str, error.get("loc", []))).replace("body", "")
+            msg = error.get("msg", "Invalid value")
+
+            ctx = error.get("ctx")
+            if ctx:
+                ctx_details = ", ".join(f"{value}" for key, value in ctx.items())
+                msg += f" {ctx_details}"
+
+            error_messages.append(f"{_(msg, request)}: {loc}")
+
+        return " | ".join(error_messages)

fk_util_tools-0.1.14/fk_utils/middlewares/fastapi/i18n.py

@@ -0,0 +1,66 @@
+import os
+import gettext
+from pathlib import Path
+import boto3
+from botocore.exceptions import BotoCoreError, ClientError
+from fastapi import Request
+from mypy_boto3_translate.client import TranslateClient
+from fk_utils.cache.redis import CacheService
+
+AWS_REGION_NAME = os.environ.get("AWS_REGION_NAME", "us-east-2")
+
+
+class TranslationWrapper:
+    def __init__(self, lang: str, translation_dir: Path, redis_url: str):
+        """Initializes the translation object for a specific language."""
+        self.lang = lang
+        self.translation_dir = translation_dir
+        self.cache_service = CacheService(redis_url)
+
+        self.translations = gettext.translation(
+            "messages",
+            localedir=self.translation_dir,
+            languages=[self.lang],
+            fallback=True,
+        )
+        self.translations.install()
+
+        self.translate_client: TranslateClient = boto3.client(
+            "translate", region_name=AWS_REGION_NAME
+        )
+
+    def gettext(self, message: str) -> str:
+        """Returns the translation from the file or AWS Translate."""
+        cache_key = f"translation:{self.lang}:{message}"
+        cached_translation = self.cache_service.get(cache_key)
+        if isinstance(cached_translation, dict) and self.lang in cached_translation:
+            return cached_translation[self.lang]
+
+        translated_message = self.translations.gettext(message)
+        if translated_message == message:
+            try:
+                response = self.translate_client.translate_text(
+                    Text=message,
+                    SourceLanguageCode="en",
+                    TargetLanguageCode=self.lang,
+                )
+                translated_message = response["TranslatedText"]
+                self.cache_service.add(
+                    cache_key, {self.lang: translated_message}, expiration_time=86400
+                )
+            except (BotoCoreError, ClientError) as e:
+                print(f"Error en AWS Translate: {e}")
+                translated_message = message
+
+        return translated_message
+
+
+async def set_locale(request: Request, translation_dir: Path, redis_url: str):
+    """Sets the language according to the 'Accept-Language' header."""
+    lang = request.headers.get("Accept-Language", "en")
+    request.state.translation = TranslationWrapper(lang, translation_dir, redis_url)
+
+
+def _(message: str, request: Request) -> str:
+    """Gets the translation of the message using the language configured in the request."""
+    return request.state.translation.gettext(message)

fk_util_tools-0.1.14/fk_utils/middlewares/fastapi/language_middleware.py

@@ -0,0 +1,21 @@
+from typing import Awaitable, Callable
+from fastapi import Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware
+from pathlib import Path
+from fk_utils.middlewares.fastapi.i18n import set_locale
+
+
+class LanguageMiddleware(BaseHTTPMiddleware):
+    def __init__(self, app, *, translation_dir: Path, redis_url: str, **kwargs):
+        super().__init__(app, **kwargs)
+        self.translation_dir = translation_dir
+        self.redis_url = redis_url
+
+    async def dispatch(
+        self,
+        request: Request,
+        call_next: Callable[[Request], Awaitable[Response]],
+    ) -> Response:
+        await set_locale(request, self.translation_dir, self.redis_url)
+        response = await call_next(request)
+        return response

fk_util_tools-0.1.14/fk_utils/middlewares/fastapi/sql_middleware.py

@@ -0,0 +1,70 @@
+import os
+import struct
+import fcntl
+import termios
+from starlette.middleware.base import BaseHTTPMiddleware
+from sqlalchemy import event
+from sqlalchemy.engine import Engine
+
+
+def terminal_width():
+    """
+    Function to compute the terminal width.
+    """
+    width = 0
+    try:
+        s = struct.pack('HHHH', 0, 0, 0, 0)
+        x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
+        width = struct.unpack('HHHH', x)[1]
+    except (struct.error, fcntl.error, termios.error) as e:
+        print(f"Error computing terminal width: {e}")
+
+    if width <= 0:
+        try:
+            width = int(os.environ['COLUMNS'])
+        except (KeyError, ValueError) as e:
+            print(f"Error getting terminal width from environment: {e}")
+
+    return width if width > 0 else 80
+
+
+class SqlPrintingMiddleware(BaseHTTPMiddleware):
+    def __init__(self, app, debug: bool = True):
+        super().__init__(app)
+        self.debug = debug
+
+    async def dispatch(self, request, call_next):
+        if self.debug:
+            request.state.queries = []
+
+            @event.listens_for(Engine, "after_cursor_execute")
+            def after_cursor_execute(conn, cursor, statement, parameters, context, executemany):
+                if not hasattr(request.state, 'queries'):
+                    request.state.queries = []
+                request.state.queries.append({
+                    'sql': statement,
+                    'time': context.execution_time
+                })
+
+        response = await call_next(request)
+
+        if self.debug and hasattr(request.state, 'queries'):
+            indentation = 2
+            print(f"\n\n{' ' * indentation}\033[1;35m[SQL Queries for]\033[1;34m {request.url.path}\033[0m\n")
+            width = terminal_width()
+            total_time = 0.0
+
+            for query in request.state.queries:
+                nice_sql = query['sql'].replace('"', '').replace(',', ', ')
+                sql = f"\033[1;31m[{query['time']}]\033[0m {nice_sql}"
+                total_time += float(query['time'])
+
+                while len(sql) > width - indentation:
+                    print(f"{' ' * indentation}{sql[:width - indentation]}")
+                    sql = sql[width - indentation:]
+                print(f"{' ' * indentation}{sql}\n")
+
+            print(f"{' ' * indentation}\033[1;32m[TOTAL TIME: {total_time} seconds]\033[0m")
+            print(f"{' ' * indentation}\033[1;32m[TOTAL QUERIES: {len(request.state.queries)}]\033[0m")
+
+        return response

fk_util_tools-0.1.14/fk_utils/middlewares/flask/sql_middleware.py

@@ -0,0 +1,66 @@
+import os
+import struct
+import fcntl
+import termios
+from flask import request, g
+from sqlalchemy import event
+from sqlalchemy.engine import Engine
+
+
+def terminal_width():
+    """
+    Function to compute the terminal width.
+    """
+    width = 0
+    try:
+        s = struct.pack('HHHH', 0, 0, 0, 0)
+        x = fcntl.ioctl(1, termios.TIOCGWINSZ, s)
+        width = struct.unpack('HHHH', x)[1]
+    except (struct.error, fcntl.error, termios.error) as e:
+        print(f"Error computing terminal width: {e}")
+
+    if width <= 0:
+        try:
+            width = int(os.environ['COLUMNS'])
+        except (KeyError, ValueError) as e:
+            print(f"Error getting terminal width from environment: {e}")
+
+    return width if width > 0 else 80
+
+
+def SqlPrintingMiddleware(app):
+    @app.before_request
+    def before_request():
+        g.queries = []
+
+    @event.listens_for(Engine, "after_cursor_execute")
+    def after_cursor_execute(conn, cursor, statement, parameters, context, executemany):
+        if 'queries' not in g:
+            g.queries = []
+        g.queries.append({
+            'sql': statement,
+            'time': context.execution_time
+        })
+
+    @app.after_request
+    def after_request(response):
+        if app.config['DEBUG'] and hasattr(g, 'queries'):
+            indentation = 2
+            print(f"\n\n{' ' * indentation}\033[1;35m[SQL Queries for]\033[1;34m {request.path}\033[0m\n")
+            width = terminal_width()
+            total_time = 0.0
+
+            for query in g.queries:
+                nice_sql = query['sql'].replace('"', '').replace(',', ', ')
+                sql = f"\033[1;31m[{query['time']}]\033[0m {nice_sql}"
+                total_time += float(query['time'])
+
+                while len(sql) > width - indentation:
+                    print(f"{' ' * indentation}{sql[:width - indentation]}")
+                    sql = sql[width - indentation:]
+                print(f"{' ' * indentation}{sql}\n")
+
+            print(f"{' ' * indentation}\033[1;32m[TOTAL TIME: {total_time} seconds]\033[0m")
+            print(f"{' ' * indentation}\033[1;32m[TOTAL QUERIES: {len(g.queries)}]\033[0m")
+
+        return response

fk_util_tools-0.1.14/fk_utils/traces/opentelemetry/django/trace.py

@@ -0,0 +1,68 @@
+# opentelemetry_config.py
+import logging
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.instrumentation.django import DjangoInstrumentor
+from opentelemetry.instrumentation.requests import RequestsInstrumentor
+from opentelemetry.instrumentation.psycopg2 import Psycopg2Instrumentor
+
+from django.apps import AppConfig
+
+from fk_utils import SETTINGS
+
+# Configurar logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def configure_tracer():
+    try:
+        # Configurar el proveedor de trazas
+        trace.set_tracer_provider(TracerProvider(
+            resource=Resource.create({"service.name": SETTINGS.OTLP_NAME})
+        ))
+
+        # Configurar el exportador OTLP
+        otlp_exporter = OTLPSpanExporter(
+            endpoint=f"{SETTINGS.OTLP_HOST}:{SETTINGS.OTLP_PORT}",
+            insecure=True
+        )
+
+        # Añadir el procesador de spans
+        trace.get_tracer_provider().add_span_processor(
+            BatchSpanProcessor(otlp_exporter)
+        )
+
+        logger.info("OpenTelemetry tracer configurado correctamente.")
+
+    except Exception as e:
+        logger.error(f"Error al configurar el tracer de OpenTelemetry: {e}")
+
+
+def instrument_app():
+    try:
+        # Instrumentar Django
+        DjangoInstrumentor().instrument()
+
+        # Instrumentar Requests
+        RequestsInstrumentor().instrument()
+
+        # Instrumentar PostgreSQL
+        Psycopg2Instrumentor().instrument()
+
+        logger.info("Aplicación instrumentada correctamente con OpenTelemetry.")
+
+    except Exception as e:
+        logger.error(f"Error al instrumentar la aplicación: {e}")
+
+
+class OpenTelemetryConfig(AppConfig):
+    name = 'fk_utils.traces.opentelemetry.django.trace'
+    verbose_name = "OpenTelemetry Integration"
+
+    def ready(self):
+        configure_tracer()
+        instrument_app()

fk_util_tools-0.1.14/fk_utils/traces/opentelemetry/fastapi/trace.py

@@ -0,0 +1,56 @@
+import logging
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
+from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
+from opentelemetry.instrumentation.requests import RequestsInstrumentor
+
+from fk_utils import SETTINGS
+
+# Configurar logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def configure_tracer():
+    try:
+        # Configurar el proveedor de trazas
+        trace.set_tracer_provider(TracerProvider(
+            resource=Resource.create({"service.name": SETTINGS.OTLP_NAME})
+        ))
+
+        # Configurar el exportador OTLP
+        otlp_exporter = OTLPSpanExporter(
+            endpoint=f"{SETTINGS.OTLP_HOST}:{SETTINGS.OTLP_PORT}",
+            insecure=True
+        )
+
+        # Añadir el procesador de spans
+        trace.get_tracer_provider().add_span_processor(
+            BatchSpanProcessor(otlp_exporter)
+        )
+
+        logger.info("OpenTelemetry tracer configurado correctamente.")
+
+    except Exception as e:
+        logger.error(f"Error al configurar el tracer de OpenTelemetry: {e}")
+
+
+def instrument_app(app):
+    try:
+        # Instrumentar FastAPI
+        FastAPIInstrumentor.instrument_app(app)
+
+        # Instrumentar SQLAlchemy
+        SQLAlchemyInstrumentor().instrument()
+
+        # Instrumentar Requests
+        RequestsInstrumentor().instrument()
+
+        logger.info("Aplicación instrumentada correctamente con OpenTelemetry.")
+
+    except Exception as e:
+        logger.error(f"Error al instrumentar la aplicación: {e}")

fk_util_tools-0.1.14/fk_utils/traces/opentelemetry/flask/trace.py

@@ -0,0 +1,59 @@
+import logging
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.instrumentation.flask import FlaskInstrumentor
+from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
+from opentelemetry.instrumentation.requests import RequestsInstrumentor
+
+from fk_utils import SETTINGS
+
+# Configurar logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def configure_tracer():
+    try:
+        # Configurar el proveedor de trazas
+        trace.set_tracer_provider(TracerProvider(
+            resource=Resource.create({"service.name": SETTINGS.OTLP_NAME})
+        ))
+
+        # Configurar el exportador OTLP
+        otlp_exporter = OTLPSpanExporter(
+            endpoint=f"{SETTINGS.OTLP_HOST}:{SETTINGS.OTLP_PORT}",
+            insecure=True
+        )
+
+        # Añadir el procesador de spans
+        trace.get_tracer_provider().add_span_processor(
+            BatchSpanProcessor(otlp_exporter)
+        )
+
+        logger.info("OpenTelemetry tracer configurado correctamente.")
+
+    except Exception as e:
+        logger.error(f"Error al configurar el tracer de OpenTelemetry: {e}")
+
+
+def instrument_app(app):
+    try:
+        # Configurar el tracer
+        configure_tracer()
+
+        # Instrumentar Flask
+        FlaskInstrumentor().instrument_app(app)
+
+        # Instrumentar SQLAlchemy
+        SQLAlchemyInstrumentor().instrument()
+
+        # Instrumentar Requests
+        RequestsInstrumentor().instrument()
+
+        logger.info("Aplicación instrumentada correctamente con OpenTelemetry.")
+
+    except Exception as e:
+        logger.error(f"Error al instrumentar la aplicación: {e}")

fk_util_tools-0.1.14/pyproject.toml

@@ -0,0 +1,28 @@
+[tool.poetry]
+name = "fk_util_tools"
+version = "0.1.14"
+description = "Herramientas de utilidad o funciones comunes para los proyectos de FK."
+authors = ["Steven Santacruz Garcia <stevengarcia1118@gmail.com>"]
+license = "MIT"
+homepage = "https://gitlab.com/f3315/team-back-end/cross/packages/package_utils"
+packages = [{include = "fk_utils"}]
+
+[tool.poetry.dependencies]
+python = ">=3.7,<4.0"
+boto3 = "*"
+opentelemetry-api = "*"
+opentelemetry-sdk = "*"
+opentelemetry-instrumentation-fastapi = "*"
+opentelemetry-instrumentation-flask = "*"
+opentelemetry-instrumentation-django = "*"
+opentelemetry-exporter-otlp = "*"
+opentelemetry-instrumentation-sqlalchemy = "*"
+opentelemetry-instrumentation-requests = "*"
+opentelemetry-exporter-jaeger = "*"
+opentelemetry-instrumentation-psycopg2 = "*"
+psycopg2-binary = "*"
+starlette = "*"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"