feat: adicionando logs pelo axiom e sentry

.env.example

@@ -9,4 +9,6 @@ BUBBLE_TOKEN=""
 LLAMA_CLOUD_API_KEY_POPS=""
 LLAMA_CLOUD_API_KEY_PEIXE=""
 DEEPSEEKK_API_KEY=""
-GOOGLE_API_KEY_PEIXE=""
+GOOGLE_API_KEY_PEIXE=""
+SENTRY_DSN=""
+AMBIENTE="testes"

_utils/custom_exception_handler.py

@@ -7,17 +7,22 @@ from rest_framework.views import exception_handler
 import logging
 from _utils.bubble_integrations.enviar_resposta_final import enviar_resposta_final
 from gerar_documento.serializer import GerarDocumentoSerializerData
+from setup.logging import Axiom
 
 logger = logging.getLogger(__name__)
 
 
 def custom_exception_handler(exc, context):
-    print("---------------- CHEGOU NA FUNÇÃO PERSONALIZADA DE ERRO ----------------")
     if context:
         serializer: Dict = context["view"].serializer
+        axiom_instance: Axiom = context["view"].axiom_instance
     else:
         serializer = {}
-    print("INICIANDO RESPOSTA DE ERRO PARA O BUBBLE")
+        axiom_instance: Axiom = Axiom()
+    axiom_instance.send_axiom_error(
+        "---------------- CHEGOU NA FUNÇÃO PERSONALIZADA DE ERRO ----------------"
+    )
+    axiom_instance.send_axiom_error("INICIANDO RESPOSTA DE ERRO PARA O BUBBLE")
     resposta_bubble = enviar_resposta_final(
         serializer.get("doc_id", ""),
         serializer.get("form_response_id", ""),
@@ -25,22 +30,25 @@ def custom_exception_handler(exc, context):
         serializer.get("texto_completo", ""),
         True,
     )
-    print("\n\nresposta_bubble.status_code", resposta_bubble.status_code)
-    print("\n\nresposta_bubble.text", resposta_bubble.text)
+    axiom_instance.send_axiom_error(
+        f"resposta_bubble.status_code: {resposta_bubble.status_code}"
+    )
+    axiom_instance.send_axiom_error(f"resposta_bubble.text: {resposta_bubble.text}")
     # Call REST framework's default exception handler first
     response = exception_handler(exc, context)
 
     if response and str(response.status_code)[0] != "2":
+        axiom_instance.send_axiom_error(f"Validation error: {response.data}")
         logger.error(f"Validation error: {response.data}")
 
     return response
 
 
 def custom_exception_handler_wihout_api_handler(
-    error, serializer: Union[GerarDocumentoSerializerData, Any]
+    error, serializer: Union[GerarDocumentoSerializerData, Any], axiom_instace: Axiom
 ):
     bahia_tz = pytz.timezone("America/Bahia")
-    print("INICIANDO RESPOSTA DE ERRO PARA O BUBBLE")
+    axiom_instace.send_axiom_error("INICIANDO RESPOSTA DE ERRO PARA O BUBBLE")
     resposta_bubble = enviar_resposta_final(
         serializer.doc_id,
         serializer.form_response_id,
@@ -48,6 +56,8 @@ def custom_exception_handler_wihout_api_handler(
         f"------------ ERRO NO BACKEND ÀS {datetime.now(bahia_tz).strftime("%d/%m/%Y - %H:%M:%S")} ------------:\nMensagem de erro: {error} ",  # serializer.get("texto_completo", ""),
         True,
     )
-    print("\n\nresposta_bubble.status_code", resposta_bubble.status_code)
-    print("\n\nresposta_bubble.text", resposta_bubble.text)
-    print("\n------------ MOTIVO DO ERRO -----------:", f"\n{error}")
+    axiom_instace.send_axiom_error(
+        f"resposta_bubble.status_code: {resposta_bubble.status_code}"
+    )
+    axiom_instace.send_axiom_error(f"resposta_bubble.text: {resposta_bubble.text}")
+    axiom_instace.send_axiom_error(f"------------ MOTIVO DO ERRO -----------: {error}")

_utils/gerar_documento.py

@@ -31,6 +31,7 @@ from gerar_documento.serializer import (
     GerarDocumentoComPDFProprioSerializerData,
     GerarDocumentoSerializerData,
 )
+from setup.logging import Axiom
 
 
 os.environ["LANGCHAIN_TRACING_V2"] = "true"
@@ -44,6 +45,7 @@ async def gerar_documento(
         GerarDocumentoSerializerData, GerarDocumentoComPDFProprioSerializerData, Any
     ],
     listaPDFs,
+    axiom_instance: Axiom,
     isBubble=False,
 ):
     """Parâmetro "contexto" só deve ser passado quando quiser utilizar o teste com ragas, e assim, não quiser passar PDFs"""
@@ -68,12 +70,17 @@ async def gerar_documento(
             response_auxiliar_summary = (
                 await get_response_from_auxiliar_contextual_prompt(full_text_as_array)
             )
+            axiom_instance.send_axiom(
+                f"RESUMO INICIAL DO PROCESSO: {response_auxiliar_summary}"
+            )
 
-            print("\nCOMEÇANDO A FAZER AS REQUISIÇÕES DO CONTEXTUAL")
+            axiom_instance.send_axiom("COMEÇANDO A FAZER AS REQUISIÇÕES DO CONTEXTUAL")
             contextualized_chunks = await contextual_retriever.contextualize_all_chunks(
                 all_PDFs_chunks, response_auxiliar_summary
             )
-            print("\nTERMINOU DE FAZER TODAS AS REQUISIÇÕES DO CONTEXTUAL")
+            axiom_instance.send_axiom(
+                "TERMINOU DE FAZER TODAS AS REQUISIÇÕES DO CONTEXTUAL"
+            )
             chunks_processados = contextualized_chunks
         else:
             chunks_processados = all_PDFs_chunks
@@ -83,14 +90,15 @@ async def gerar_documento(
             cast(str, response_auxiliar_summary)
         )
 
-        print("\nCOMEÇANDO REQUISIÇÃO PARA GERAR O QUERY DINAMICAMENTE DO VECTOR STORE")
+        axiom_instance.send_axiom(
+            "COMEÇANDO REQUISIÇÃO PARA GERAR O QUERY DINAMICAMENTE DO VECTOR STORE"
+        )
         query_gerado_dinamicamente_para_o_vector_store = await llm.google_gemini(
             "gemini-2.5-pro-exp-03-25"
         ).ainvoke([HumanMessage(content=prompt_para_gerar_query_dinamico)])
 
-        print(
-            "\nquery_gerado_dinamicamente_para_o_vector_store: ",
-            query_gerado_dinamicamente_para_o_vector_store.content,
+        axiom_instance.send_axiom(
+            f"query_gerado_dinamicamente_para_o_vector_store: {query_gerado_dinamicamente_para_o_vector_store.content}",
         )
 
         # Create enhanced vector store and BM25 index
@@ -101,7 +109,7 @@ async def gerar_documento(
         )
 
         llm_ultimas_requests = serializer.llm_ultimas_requests
-        print("\nCOMEÇANDO A FAZER ÚLTIMA REQUISIÇÃO")
+        axiom_instance.send_axiom("COMEÇANDO A FAZER ÚLTIMA REQUISIÇÃO")
         structured_summaries = await summarizer.gerar_documento_final(
             vector_store,
             bm25,
@@ -111,7 +119,7 @@ async def gerar_documento(
                 str, query_gerado_dinamicamente_para_o_vector_store.content
             ),  # prompt_auxiliar_SEM_CONTEXT,
         )
-        print("\nTERMINOU DE FAZER A ÚLTIMA REQUISIÇÃO")
+        axiom_instance.send_axiom("TERMINOU DE FAZER A ÚLTIMA REQUISIÇÃO")
 
         if not isinstance(structured_summaries, list):
             from rest_framework.response import Response
@@ -126,7 +134,9 @@ async def gerar_documento(
             x["source"]["context"] = x["source"]["context"][0:200]
 
         texto_completo_como_html = convert_markdown_to_HTML(texto_completo)
-        print("\ntexto_completo_como_html", texto_completo_como_html)
+        axiom_instance.send_axiom(
+            f"texto_completo_como_html: {texto_completo_como_html}"
+        )
 
         if is_contextualized_chunk:
             prompt_titulo_do_documento = response_auxiliar_summary
@@ -137,7 +147,7 @@ async def gerar_documento(
         )
 
         if isBubble:
-            print("COMEÇANDO A REQUISIÇÃO FINAL PARA O BUBBLE")
+            axiom_instance.send_axiom("COMEÇANDO A REQUISIÇÃO FINAL PARA O BUBBLE")
             enviar_resposta_final(
                 serializer.doc_id,  # type: ignore
                 serializer.form_response_id,  # type: ignore
@@ -146,7 +156,7 @@ async def gerar_documento(
                 False,
                 cast(str, titulo_do_documento),
             )
-            print("TERMINOU A REQUISIÇÃO FINAL PARA O BUBBLE")
+            axiom_instance.send_axiom("TERMINOU A REQUISIÇÃO FINAL PARA O BUBBLE")
 
         return {
             "texto_completo": texto_completo_como_html,
@@ -155,5 +165,5 @@ async def gerar_documento(
             "parametros-utilizados": gerar_resposta_compilada(serializer),
         }
     except Exception as e:
-        custom_exception_handler_wihout_api_handler(e, serializer)
+        custom_exception_handler_wihout_api_handler(e, serializer, axiom_instance)
         raise

_utils/handle_files.py

@@ -5,6 +5,7 @@ from llama_index import Document
 from llama_parse import LlamaParse, ResultType
 
 from _utils.langchain_utils.splitter_util import SplitterUtils
+from setup.logging import Axiom
 
 llama_parser_keys = [
     os.getenv("LLAMA_CLOUD_API_KEY_POPS"),
@@ -12,7 +13,7 @@ llama_parser_keys = [
 ]
 
 
-def handle_pdf_files_from_serializer(files):
+def handle_pdf_files_from_serializer(files, axiom_instance: Axiom):
     listaPDFs = []
     for file in files:
         file_extension = file.name.split(".")[-1]
@@ -26,7 +27,7 @@ def handle_pdf_files_from_serializer(files):
                 temp_file.write(chunk)
             temp_file_path = temp_file.name  # Get the path of the temporary file
             listaPDFs.append(temp_file_path)
-    print("\n\nlistaPDFs: ", listaPDFs)
+    axiom_instance.send_axiom(f"listaPDFs: {listaPDFs}")
     return listaPDFs
 
 

_utils/langchain_utils/Splitter_class.py

@@ -25,6 +25,7 @@ class Splitter:
         chunk_size,
         chunk_overlap,
     ):
+        self.splitter_simple = Splitter_Simple(chunk_size, chunk_overlap)
         self.text_splitter = RecursiveCharacterTextSplitter(
             chunk_size=chunk_size, chunk_overlap=chunk_overlap
         )
@@ -41,7 +42,7 @@ class Splitter:
         #     )  # Gera uma lista de objetos Document, sendo cada item da lista referente a UMA PÁGINA inteira do PDF.
         full_text_as_string = ""
 
-        initial_chunks: List[str] = []
+        chunks_of_string_only: List[str] = []
 
         if isBubble:
             print("\nPEGANDO PDF DO BUBBLE")
@@ -49,11 +50,17 @@ class Splitter:
             page_boundaries, combined_text = (
                 combine_documents_without_losing_pagination(pages)
             )
-            for page in pages:
-                full_text_as_string = full_text_as_string + page.page_content
-            initial_chunks = initial_chunks + self.text_splitter.split_text(
-                combined_text
+            chunks_of_string_only = (
+                chunks_of_string_only
+                + self.splitter_simple.get_chunks_of_string_only_from_list_of_documents(
+                    pages
+                )
             )
+            # for page in pages:
+            #     full_text_as_string = full_text_as_string + page.page_content
+            # chunks_of_string_only = chunks_of_string_only + self.text_splitter.split_text(
+            #     combined_text
+            # )
         else:
             if should_use_llama_parse:
                 print("\nENVIANDO PDFS PARA LLAMA PARSE")
@@ -61,8 +68,8 @@ class Splitter:
                 page_boundaries, combined_text = (
                     combine_documents_without_losing_pagination(pages)
                 )
-                initial_chunks = initial_chunks + self.text_splitter.split_text(
-                    combined_text
+                chunks_of_string_only = (
+                    chunks_of_string_only + self.text_splitter.split_text(combined_text)
                 )
             else:
                 print("\nCOMEÇANDO LEITURA DO PDF")
@@ -78,8 +85,8 @@ class Splitter:
                     combine_documents_without_losing_pagination(pages)
                 )
 
-                initial_chunks = initial_chunks + self.text_splitter.split_text(
-                    combined_text
+                chunks_of_string_only = (
+                    chunks_of_string_only + self.text_splitter.split_text(combined_text)
                 )
 
         chunks: List[DocumentChunk] = []
@@ -92,7 +99,7 @@ class Splitter:
         #     )  # Quebra o item que é um Document de UMA PÁGINA inteira em um lista onde cada item é referente a um chunk, que são pedaços menores do que uma página.
         text_char = 0
         print("\nQUEBRANDO PDF EM CHUNKS ORGANIZADOS")
-        for chunk in initial_chunks:
+        for chunk in chunks_of_string_only:
             chunk_id = str(uuid.uuid4())
             start_char = text_char + 1
             end_char = start_char + len(chunk)
@@ -129,7 +136,7 @@ class Splitter:
             # char_count += len(text)
         print("TERMINOU DE ORGANIZAR PDFS EM CHUNKS")
 
-        return chunks, initial_chunks, full_text_as_string
+        return chunks, chunks_of_string_only, full_text_as_string
 
     def load_and_split_text(self, text: str) -> List[DocumentChunk]:
         """Load Text and split into chunks with metadata - Criei essa função apenas para o ragas"""
@@ -198,3 +205,12 @@ class Splitter_Simple:
             documents.append(Document(page_content=chunk))
 
         return documents
+
+    def get_chunks_of_string_only_from_list_of_documents(
+        self, lista_de_documentos: List[Document]
+    ):
+        full_text_as_string = ""
+        for page in lista_de_documentos:
+            full_text_as_string = full_text_as_string + page.page_content
+        full_text_as_array = self.text_splitter.split_text(full_text_as_string)
+        return full_text_as_array

_utils/utils.py

@@ -15,6 +15,7 @@ import numpy as np
 import openai
 import pandas as pd
 import markdown
+import sentry_sdk
 
 os.environ["LANGCHAIN_TRACING_V2"] = "true"
 os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"
@@ -223,3 +224,26 @@ def convert_markdown_to_HTML(text: str):
         .replace("\n", "\n\n")
     )
     return html
+
+
+def print_sentry(mensagem: str):
+    sentry_sdk.capture_message(mensagem, level="info")
+
+
+def sentry_add_breadcrumb(mensagem: str):
+    sentry_sdk.add_breadcrumb(
+        category="infos_gerais",
+        message=mensagem,
+        level="info",
+    )
+
+
+def sentry_add_trace(mensagem: str):
+    current_span = sentry_sdk.get_current_span()
+
+    if current_span is not None:
+        # Set custom tags
+        current_span.set_tag("NOME DA TAG", "VALOR DA TAG")
+
+        # Add custom data
+        current_span.set_data("NOME DA KEY", mensagem)

gerar_documento/views.py

@@ -5,6 +5,7 @@ from _utils.gerar_relatorio_modelo_usuario.utils import (
     get_full_text_and_all_PDFs_chunks,
 )
 from _utils.langchain_utils.Prompt_class import Prompt
+from _utils.utils import print_sentry, sentry_add_breadcrumb
 from setup.easy_imports import (
     Response,
     AsyncAPIView,
@@ -18,6 +19,7 @@ from _utils.gerar_documento import (
     gerar_documento,
 )
 from _utils.gerar_relatorio_modelo_usuario.prompts import prompt_auxiliar_inicio
+from setup.logging import Axiom, send_axiom
 from .serializer import (
     GerarDocumentoComPDFProprioSerializer,
     GerarDocumentoSerializer,
@@ -35,8 +37,10 @@ class GerarDocumentoView(AsyncAPIView):
         request=GerarDocumentoSerializer,
     )
     async def post(self, request):
+        axiom_instance = Axiom()
         print(f"\n\nDATA E HORA DA REQUISIÇÃO: {datetime.now()}")
-        print("request.data: ", request.data)
+        axiom_instance.send_axiom("COMEÇOU NOVA REQUISIÇÃO")
+        axiom_instance.send_axiom(request.data)
         serializer = GerarDocumentoSerializer(data=request.data)
         if serializer.is_valid(raise_exception=True):
             obj = serializer.get_obj()  # type: ignore
@@ -46,15 +50,16 @@ class GerarDocumentoView(AsyncAPIView):
             async def proccess_data_after_response():
                 # await asyncio.sleep(0)
                 data = cast(Dict[str, Any], serializer.validated_data)
-                print("\ndata: ", data)
                 self.serializer = data
 
                 listaPDFs = [l["link_arquivo"] for l in data["files"]]
 
-                print("\n\nlistaPDFs: ", listaPDFs)
+                axiom_instance.send_axiom(f"listaPDFs: {listaPDFs}")
 
-                resposta_llm = await gerar_documento(obj, listaPDFs, True)
-                print("\n\nresposta_llm: ", resposta_llm)
+                resposta_llm = await gerar_documento(
+                    obj, listaPDFs, axiom_instance, isBubble=True
+                )
+                axiom_instance.send_axiom(f"resposta_llm: {resposta_llm}")
 
                 # remove_pdf_temp_files(listaPDFs)
 
@@ -77,21 +82,26 @@ class GerarDocumentoComPDFProprioView(AsyncAPIView):
         request=GerarDocumentoComPDFProprioSerializer,
     )
     async def post(self, request):
+        axiom_instance = Axiom()
         print(f"\n\nDATA E HORA DA REQUISIÇÃO: {datetime.now()}")
+        axiom_instance.send_axiom("COMEÇOU NOVA REQUISIÇÃO")
+        axiom_instance.send_axiom(request.data)
         serializer = GerarDocumentoComPDFProprioSerializer(data=request.data)
+
         if serializer.is_valid(raise_exception=True):
             data = cast(Dict[str, Any], serializer.validated_data)
             obj = serializer.get_obj()  # type: ignore
-            print("\n\ndata: ", data)
             self.serializer = data
 
-            listaPDFs = handle_pdf_files_from_serializer(data["files"])
+            listaPDFs = handle_pdf_files_from_serializer(data["files"], axiom_instance)
 
-            resposta_llm = await gerar_documento(obj, listaPDFs)
-            print("\n\nresposta_llm: ", resposta_llm)
+            resposta_llm = await gerar_documento(obj, listaPDFs, axiom_instance)
+            axiom_instance.send_axiom(f"resposta_llm: {resposta_llm}")
 
             remove_pdf_temp_files(listaPDFs)
-            print("PRÓXIMA LINHA ENVIA A RESPOSTA A QUEM FEZ A REQUISIÇÃO")
+            axiom_instance.send_axiom(
+                "PRÓXIMA LINHA ENVIA A RESPOSTA A QUEM FEZ A REQUISIÇÃO"
+            )
             return Response({"resposta": resposta_llm})
 
 

setup/logging.py

@@ -0,0 +1,74 @@
+import logging
+from attr import dataclass
+from axiom_py import Client
+from axiom_py.logging import AxiomHandler
+import uuid
+from setup.tokens import ambiente
+
+
+def configure_logging():
+    # Initialize the Axiom client
+    axiom_client = Client("xaat-a5f9395e-9884-4b57-a537-a32e810cdb0a")
+    # client.ingest_events(
+    #     dataset="vella",
+    #     events=[
+    #         {"foo": "bar"},
+    #         {"bar": "baz"},
+    #     ],
+    # )
+
+    # Create an Axiom logging handler
+    axiom_handler = AxiomHandler(client=axiom_client, dataset="vella")
+
+    # Set the logging level for the handler
+    axiom_handler.setLevel(logging.INFO)
+
+    # Optional: Define a formatter for the logs
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+    axiom_handler.setFormatter(formatter)
+
+    # Get the root logger and add the Axiom handler
+    root_logger = logging.getLogger()
+    root_logger.setLevel(logging.INFO)
+    root_logger.addHandler(axiom_handler)
+
+
+def send_axiom(mensagem):
+    logger = logging.getLogger()
+    logger.info(
+        mensagem,
+        extra={
+            "tags": ["ambiente_testes"],
+        },
+    )
+
+
+@dataclass
+class Axiom:
+    uuid = uuid.uuid4()
+
+    array_of_logs = []
+
+    def add_axiom(self, mensagem):
+        self.array_of_logs.append(mensagem)
+
+    def send_final_axiom(self):
+        send_axiom(self.array_of_logs)
+
+    def send_axiom(self, mensagem):
+        print("\n", mensagem)
+        logger = logging.getLogger()
+        logger.info(
+            mensagem,
+            extra={"ambiente": [ambiente], "uuid": self.uuid},
+        )
+
+    def send_axiom_error(self, mensagem):
+        print("\n", mensagem)
+        logger = logging.getLogger()
+        logger.info(
+            mensagem,
+            extra={"ambiente": [ambiente], "uuid": self.uuid, "error": "true"},
+        )

setup/settings.py

@@ -1,6 +1,10 @@
 import os
 from dotenv import load_dotenv
 from setup.installed_apps import INSTALLED_APPS
+import sentry_sdk
+from sentry_sdk.integrations.django import DjangoIntegration
+
+from setup.logging import configure_logging
 
 load_dotenv()
 
@@ -142,7 +146,7 @@ CORS_ORIGIN_WHITELIST = [
 ]
 
 REST_FRAMEWORK = {
-    'EXCEPTION_HANDLER': "_utils.custom_exception_handler.custom_exception_handler",
+    "EXCEPTION_HANDLER": "_utils.custom_exception_handler.custom_exception_handler",
     "DEFAULT_PAGINATION_CLASS": "rest_framework.pagination.PageNumberPagination",
     "PAGE_SIZE": 10,
     "DEFAULT_SCHEMA_CLASS": "drf_spectacular.openapi.AutoSchema",
@@ -161,3 +165,23 @@ SPECTACULAR_SETTINGS = {
     "COMPONENT_SPLIT_REQUEST": True,
     # OTHER SETTINGS
 }
+
+sentry_sdk.init(
+    dsn=os.environ.get("SENTRY_DSN"),
+    integrations=[DjangoIntegration()],
+    # Add data like request headers and IP for users,
+    # see https://docs.sentry.io/platforms/python/data-management/data-collected/ for more info
+    send_default_pii=True,
+    # Set traces_sample_rate to 1.0 to capture 100%
+    # of transactions for tracing.
+    traces_sample_rate=1.0,
+    # Set profile_session_sample_rate to 1.0 to profile 100%
+    # of profile sessions.
+    profile_session_sample_rate=1.0,
+    # Set profile_lifecycle to "trace" to automatically
+    # run the profiler on when there is an active transaction
+    profile_lifecycle="trace",
+    max_request_body_size="always",
+)
+
+configure_logging()

setup/tokens.py

@@ -1,5 +1,5 @@
 import os
-from typing import cast
+from typing import Literal, cast
 
 openai_api_key = cast(str, os.environ.get("OPENAI_API_KEY", ""))
 claude_api_key = cast(str, os.environ.get("CLAUDE_API_KEY"))
@@ -9,3 +9,6 @@ bubble_token = cast(str, os.environ.get("BUBBLE_TOKEN"))
 cohere_api_key = cast(str, os.environ.get("COHERE_API_KEY", ""))
 deepseek_api_key = cast(str, os.environ.get("DEEPSEEKK_API_KEY"))
 google_api_key = cast(str, os.environ.get("GOOGLE_API_KEY_PEIXE"))
+ambiente: Literal["prd", "testes"] = cast(
+    Literal["prd", "testes"], os.environ.get("AMBIENTE", "prd")
+)