csc-cia-stne 0.0.13__py3-none-any.whl

csc_cia_stne/karavela.py

@@ -0,0 +1,123 @@
+import os
+
+class Karavela():
+
+    def __init__(self)->None:
+        """Inicia a instância da classe Karavela
+
+        """
+        self.healthy_check_file = None
+    
+    def create_health_check_file(self,health_check_filename:str = None)->bool:
+        """Cria o arquivo de health check
+
+        Args:
+            health_check_file (str): nome do arquivo de health check a ser criado
+        Returns:
+            bool: True
+        """
+        
+        if health_check_filename is None or health_check_filename == "":
+            
+            raise ValueError("O método 'create_health_check_file' precisa do parâmetro health_check_filename especificado")
+        
+        self.health_check_filename = health_check_filename
+
+        try:
+
+            if not os.path.exists(self.health_check_filename):
+
+                directory = os.path.dirname(self.health_check_filename)
+
+                if not os.path.exists(directory) and str(directory).strip() != "":
+             
+                    os.makedirs(directory)
+                
+            with open(f'{self.health_check_filename}', 'w') as f:
+                           
+                f.write('OK!')
+                return True
+            
+        except Exception as e:
+        
+            raise e
+    
+    def destroy_health_check_file(self)->bool:
+        """Deleta o arquivo de health check
+
+        Returns:
+            bool: True
+        """
+        
+        if self.health_check_filename is None:
+        
+            raise ValueError("O método 'create_health_check_file' precisa ser executado antes")
+        
+        try:
+
+            if os.path.exists(self.health_check_filename):
+
+                os.remove(self.health_check_filename)
+                return True
+                
+            else:
+            
+                return True
+                    
+        except Exception as e:
+        
+            raise e
+    
+    def get_secret(self,name:str)->str:
+        """Extrai a secret do ambiente
+
+        Args:
+            name (str): nome da variavel ou arquivo da secret
+
+        Returns:
+            str: string da secret armazenada na variável de ambiente ou no arquivo de secret
+        """
+        
+        # Tentando extrair da variavel de ambiente
+        secret = os.getenv(name)
+        
+        # secret não encontrada em variavel de ambiente, tentando extrair do arquivo em /secret
+        if secret is None:
+
+            # verifica na pasta ./secrets
+            if os.path.exists(f"./secrets/{name}"):
+
+                with open(f"./secrets/{name}",'r') as secret_file:
+            
+                    secret = secret_file.read()
+
+            # verifica na pasta ./.secrets
+            elif os.path.exists(f"./.secrets/{name}"):
+
+                with open(f"./.secrets/{name}",'r') as secret_file:
+            
+                    secret = secret_file.read()
+
+            # verifica na pasta ./private
+            elif os.path.exists(f"./private/{name}"):
+
+                with open(f"./private/{name}",'r') as secret_file:
+            
+                    secret = secret_file.read()
+
+            # verifica na pasta ./.private
+            elif os.path.exists(f"./.private/{name}"):
+
+                with open(f"./.private/{name}",'r') as secret_file:
+            
+                    secret = secret_file.read()
+
+            # verifica na pasta /secrets
+            elif os.path.exists(f"/secrets/{name}"):
+
+                with open(f"/secrets/{name}",'r') as secret_file:
+            
+                    secret = secret_file.read()
+
+        return secret
+    

csc_cia_stne/logger.py

@@ -0,0 +1,155 @@
+import os
+import logging
+import colorlog
+from pythonjsonlogger import jsonlogger
+
+
+# Strategy para formatação dos logs
+class LogFormatterStrategy:
+    """
+    Interface para estratégia de formatação de logs.
+    Define o método `format`, que deve ser implementado pelas subclasses.
+    """
+
+    def format(self, log_handler, date_format):
+        """
+        Aplica a formatação do log ao handler fornecido.
+
+        Parâmetros:
+            log_handler (logging.Handler): O handler que receberá a formatação.
+            date_format (str): O formato da data para os logs.
+
+        Retorna:
+            None
+        """
+        raise NotImplementedError("O método format() deve ser implementado")
+
+
+class ColorLogFormatter(LogFormatterStrategy):
+    """
+    Implementação da estratégia de formatação de logs coloridos para uso local.
+    """
+
+    def format(self, log_handler, date_format):
+        """
+        Aplica a formatação colorida ao handler de log.
+
+        Parâmetros:
+            log_handler (logging.Handler): O handler que receberá a formatação.
+            date_format (str): O formato da data para os logs.
+
+        Retorna:
+            None
+        """
+        formatter = colorlog.ColoredFormatter(
+            "%(asctime)s - %(log_color)s%(levelname)s%(reset)s - %(message)s",
+            datefmt=date_format,
+            log_colors={
+                "DEBUG": "reset",
+                "INFO": "green",
+                "WARNING": "yellow",
+                "ERROR": "red",
+                "CRITICAL": "bold_red",
+            },
+        )
+        log_handler.setFormatter(formatter)
+
+
+class JsonLogFormatter(LogFormatterStrategy):
+    """
+    Implementação da estratégia de formatação de logs em JSON, ideal para ambientes como Docker.
+    """
+
+    def format(self, log_handler, date_format):
+        """
+        Aplica a formatação JSON ao handler de log.
+
+        Parâmetros:
+            log_handler (logging.Handler): O handler que receberá a formatação.
+            date_format (str): O formato da data para os logs.
+
+        Retorna:
+            None
+        """
+        formatter = jsonlogger.JsonFormatter(
+            "%(asctime)s - %(levelname)s - %(message)s", datefmt=date_format
+        )
+        log_handler.setFormatter(formatter)
+
+
+# Factory para criar o logger
+class LoggerFactory:
+    """
+    Classe de fábrica responsável por criar e configurar loggers.
+    """
+
+    @staticmethod
+    def create_logger(name):
+        """
+        Cria e retorna um logger configurado com o nome especificado.
+
+        Parâmetros:
+            name (str): O nome do logger.
+
+        Retorna:
+            logging.Logger: O logger configurado.
+        """
+        try:
+            if not os.path.exists("./tmp"):
+                os.makedirs("./tmp")
+        except OSError as e:
+            print(f"Erro ao criar o diretório './tmp': {e}")
+            raise
+
+        logger = logging.getLogger(name)
+        logger.setLevel(logging.INFO)
+        log_handler = logging.StreamHandler()
+        date_format = "%d-%m-%Y %H:%M:%S"
+
+        # Define a estratégia de formatação dependendo do ambiente
+        if LoggerFactory.not_docker():
+            formatter_strategy = ColorLogFormatter()
+
+            # Configura o handler para salvar logs em arquivo
+            file_handler = logging.FileHandler("tmp/log.txt")
+            file_handler.setFormatter(
+                logging.Formatter(
+                    "%(asctime)s - %(levelname)s - %(message)s",
+                    datefmt=date_format,
+                )
+            )
+            logger.addHandler(file_handler)
+        else:
+            formatter_strategy = JsonLogFormatter()
+            print("Rodando em container, logs em JSON")
+
+        # Aplica a estratégia de formatação
+        formatter_strategy.format(log_handler, date_format)
+        logger.addHandler(log_handler)
+
+        return logger
+
+    @staticmethod
+    def not_docker():
+        """
+        Verifica se o código está sendo executado em um container Docker.
+
+        Retorna:
+            bool: False se estiver rodando em um container Docker, True se estiver rodando localmente.
+        """
+        if os.path.exists("/.dockerenv"):
+            return False
+
+        try:
+            with open("/proc/1/cgroup", "rt") as file:
+                for line in file:
+                    if "docker" in line or "kubepods" in line:
+                        return False
+        except Exception:
+            print("Logger sendo executado localmente.")
+
+        return True
+
+
+# Uso do logger
+logger = LoggerFactory.create_logger(__name__)