logdetective 0.5.11__py3-none-any.whl → 0.6.0__py3-none-any.whl

logdetective/logdetective.py

@@ -1,8 +1,11 @@
 import argparse
+import asyncio
 import logging
 import sys
 import os
 
+import aiohttp
+
 from logdetective.constants import DEFAULT_ADVISOR, DEFAULT_TEMPERATURE
 from logdetective.utils import (
     process_log,
@@ -82,7 +85,7 @@ def setup_args():
     return parser.parse_args()
 
 
-def main():  # pylint: disable=too-many-statements,too-many-locals
+async def run():  # pylint: disable=too-many-statements,too-many-locals
     """Main execution function."""
     args = setup_args()
 
@@ -128,13 +131,14 @@ def main():  # pylint: disable=too-many-statements,too-many-locals
 
     LOG.info("Getting summary")
 
-    try:
-        log = retrieve_log_content(args.file)
-    except ValueError as e:
-        # file does not exists
-        LOG.error(e)
-        sys.exit(4)
-    log_summary = extractor(log)
+    async with aiohttp.ClientSession() as http:
+        try:
+            log = await retrieve_log_content(http, args.file)
+        except ValueError as e:
+            # file does not exist
+            LOG.error(e)
+            sys.exit(4)
+        log_summary = extractor(log)
 
     ratio = len(log_summary) / len(log.split("\n"))
 
@@ -182,5 +186,10 @@ def main():  # pylint: disable=too-many-statements,too-many-locals
     print(f"\nResponse certainty: {certainty:.2f}%\n")
 
 
+def main():
+    """ Evaluate logdetective program and wait for it to finish """
+    asyncio.run(run())
+
+
 if __name__ == "__main__":
     main()

logdetective/server/server.py

@@ -3,6 +3,7 @@ import json
 import os
 import re
 import zipfile
+from contextlib import asynccontextmanager
 from pathlib import Path, PurePath
 from tempfile import TemporaryFile
 from typing import List, Annotated, Tuple, Dict, Any
@@ -11,7 +12,7 @@ from io import BytesIO
 
 import matplotlib
 import matplotlib.pyplot
-from fastapi import FastAPI, HTTPException, BackgroundTasks, Depends, Header
+from fastapi import FastAPI, HTTPException, BackgroundTasks, Depends, Header, Request
 
 from fastapi.responses import StreamingResponse
 from fastapi.responses import Response as BasicResponse
@@ -19,14 +20,14 @@ import gitlab
 import gitlab.v4
 import gitlab.v4.objects
 import jinja2
-import requests
+import aiohttp
 
 from logdetective.extractors import DrainExtractor
 from logdetective.utils import (
-    validate_url,
     compute_certainty,
     format_snippets,
     load_prompts,
+    get_url_content,
 )
 from logdetective.server.utils import (
     load_server_config,
@@ -61,6 +62,27 @@ FAILURE_LOG_REGEX = re.compile(r"(\w*\.log)")
 LOG = get_log(SERVER_CONFIG)
 
 
+@asynccontextmanager
+async def lifespan(fapp: FastAPI):
+    """
+    Establish one HTTP session
+    """
+    fapp.http = aiohttp.ClientSession(
+        timeout=aiohttp.ClientTimeout(
+            total=int(LOG_SOURCE_REQUEST_TIMEOUT), connect=3.07
+        )
+    )
+    yield
+    await fapp.http.close()
+
+
+async def get_http_session(request: Request) -> aiohttp.ClientSession:
+    """
+    Return the single aiohttp ClientSession for this app
+    """
+    return request.app.http
+
+
 def requires_token_when_set(authentication: Annotated[str | None, Header()] = None):
     """
     FastAPI Depend function that expects a header named Authentication
@@ -91,33 +113,20 @@ def requires_token_when_set(authentication: Annotated[str | None, Header()] = No
     raise HTTPException(status_code=401, detail=f"Token {token} not valid.")
 
 
-app = FastAPI(dependencies=[Depends(requires_token_when_set)])
+app = FastAPI(dependencies=[Depends(requires_token_when_set)], lifespan=lifespan)
 app.gitlab_conn = gitlab.Gitlab(
     url=SERVER_CONFIG.gitlab.url, private_token=SERVER_CONFIG.gitlab.api_token
 )
 
 
-def process_url(url: str) -> str:
+async def process_url(http: aiohttp.ClientSession, url: str) -> str:
     """Validate log URL and return log text."""
-    if validate_url(url=url):
-        try:
-            log_request = requests.get(url, timeout=int(LOG_SOURCE_REQUEST_TIMEOUT))
-        except requests.RequestException as ex:
-            raise HTTPException(
-                status_code=400, detail=f"We couldn't obtain the logs: {ex}"
-            ) from ex
-
-        if not log_request.ok:
-            raise HTTPException(
-                status_code=400,
-                detail="Something went wrong while getting the logs: "
-                f"[{log_request.status_code}] {log_request.text}",
-            )
-    else:
-        LOG.error("Invalid URL received ")
-        raise HTTPException(status_code=400, detail=f"Invalid log URL: {url}")
-
-    return log_request.text
+    try:
+        return await get_url_content(http, url, timeout=int(LOG_SOURCE_REQUEST_TIMEOUT))
+    except RuntimeError as ex:
+        raise HTTPException(
+            status_code=400, detail=f"We couldn't obtain the logs: {ex}"
+        ) from ex
 
 
 def mine_logs(log: str) -> List[Tuple[int, str]]:
@@ -137,7 +146,11 @@ def mine_logs(log: str) -> List[Tuple[int, str]]:
 
 
 async def submit_to_llm_endpoint(
-    url: str, data: Dict[str, Any], headers: Dict[str, str], stream: bool
+    http: aiohttp.ClientSession,
+    url: str,
+    data: Dict[str, Any],
+    headers: Dict[str, str],
+    stream: bool,
 ) -> Any:
     """Send request to selected API endpoint. Verifying successful request unless
     the using the stream response.
@@ -147,40 +160,41 @@ async def submit_to_llm_endpoint(
     headers:
     stream:
     """
+    LOG.debug("async request %s headers=%s data=%s", url, headers, data)
     try:
-        # Expects llama-cpp server to run on LLM_CPP_SERVER_ADDRESS:LLM_CPP_SERVER_PORT
-        response = requests.post(
+        response = await http.post(
             url,
             headers=headers,
-            data=json.dumps(data),
+            # we need to use the `json=` parameter here and let aiohttp
+            # handle the json-encoding
+            json=data,
             timeout=int(LLM_CPP_SERVER_TIMEOUT),
-            stream=stream,
+            # Docs says chunked takes int, but:
+            #   DeprecationWarning: Chunk size is deprecated #1615
+            # So let's make sure we either put True or None here
+            chunked=True if stream else None,
+            raise_for_status=True,
         )
-    except requests.RequestException as ex:
-        LOG.error("Llama-cpp query failed: %s", ex)
+    except aiohttp.ClientResponseError as ex:
         raise HTTPException(
-            status_code=400, detail=f"Llama-cpp query failed: {ex}"
+            status_code=400,
+            detail="HTTP Error while getting response from inference server "
+            f"[{ex.status}] {ex.message}",
+        ) from ex
+    if stream:
+        return response
+    try:
+        return json.loads(await response.text())
+    except UnicodeDecodeError as ex:
+        LOG.error("Error encountered while parsing llama server response: %s", ex)
+        raise HTTPException(
+            status_code=400,
+            detail=f"Couldn't parse the response.\nError: {ex}\nData: {response.text}",
         ) from ex
-    if not stream:
-        if not response.ok:
-            raise HTTPException(
-                status_code=400,
-                detail="Something went wrong while getting a response from the llama server: "
-                f"[{response.status_code}] {response.text}",
-            )
-        try:
-            response = json.loads(response.text)
-        except UnicodeDecodeError as ex:
-            LOG.error("Error encountered while parsing llama server response: %s", ex)
-            raise HTTPException(
-                status_code=400,
-                detail=f"Couldn't parse the response.\nError: {ex}\nData: {response.text}",
-            ) from ex
-
-    return response
 
 
 async def submit_text(  # pylint: disable=R0913,R0917
+    http: aiohttp.ClientSession,
     text: str,
     max_tokens: int = -1,
     log_probs: int = 1,
@@ -200,14 +214,15 @@ async def submit_text(  # pylint: disable=R0913,R0917
 
     if SERVER_CONFIG.inference.api_endpoint == "/chat/completions":
         return await submit_text_chat_completions(
-            text, headers, max_tokens, log_probs > 0, stream, model
+            http, text, headers, max_tokens, log_probs > 0, stream, model
         )
     return await submit_text_completions(
-        text, headers, max_tokens, log_probs, stream, model
+        http, text, headers, max_tokens, log_probs, stream, model
     )
 
 
 async def submit_text_completions(  # pylint: disable=R0913,R0917
+    http: aiohttp.ClientSession,
     text: str,
     headers: dict,
     max_tokens: int = -1,
@@ -230,6 +245,7 @@ async def submit_text_completions(  # pylint: disable=R0913,R0917
     }
 
     response = await submit_to_llm_endpoint(
+        http,
         f"{SERVER_CONFIG.inference.url}/v1/completions",
         data,
         headers,
@@ -242,6 +258,7 @@ async def submit_text_completions(  # pylint: disable=R0913,R0917
 
 
 async def submit_text_chat_completions(  # pylint: disable=R0913,R0917
+    http: aiohttp.ClientSession,
     text: str,
     headers: dict,
     max_tokens: int = -1,
@@ -270,6 +287,7 @@ async def submit_text_chat_completions(  # pylint: disable=R0913,R0917
     }
 
     response = await submit_to_llm_endpoint(
+        http,
         f"{SERVER_CONFIG.inference.url}/v1/chat/completions",
         data,
         headers,
@@ -289,17 +307,20 @@ async def submit_text_chat_completions(  # pylint: disable=R0913,R0917
 
 @app.post("/analyze", response_model=Response)
 @track_request()
-async def analyze_log(build_log: BuildLog):
+async def analyze_log(
+    build_log: BuildLog, http: aiohttp.ClientSession = Depends(get_http_session)
+):
     """Provide endpoint for log file submission and analysis.
     Request must be in form {"url":"<YOUR_URL_HERE>"}.
     URL must be valid for the request to be passed to the LLM server.
     Meaning that it must contain appropriate scheme, path and netloc,
     while lacking  result, params or query fields.
     """
-    log_text = process_url(build_log.url)
+    log_text = await process_url(http, build_log.url)
     log_summary = mine_logs(log_text)
     log_summary = format_snippets(log_summary)
     response = await submit_text(
+        http,
         PROMPT_CONFIG.prompt_template.format(log_summary),
         model=SERVER_CONFIG.inference.model,
         max_tokens=SERVER_CONFIG.inference.max_tokens,
@@ -321,19 +342,23 @@ async def analyze_log(build_log: BuildLog):
 
 @app.post("/analyze/staged", response_model=StagedResponse)
 @track_request()
-async def analyze_log_staged(build_log: BuildLog):
+async def analyze_log_staged(
+    build_log: BuildLog, http: aiohttp.ClientSession = Depends(get_http_session)
+):
     """Provide endpoint for log file submission and analysis.
     Request must be in form {"url":"<YOUR_URL_HERE>"}.
     URL must be valid for the request to be passed to the LLM server.
     Meaning that it must contain appropriate scheme, path and netloc,
     while lacking  result, params or query fields.
     """
-    log_text = process_url(build_log.url)
+    log_text = await process_url(http, build_log.url)
 
-    return await perform_staged_analysis(log_text=log_text)
+    return await perform_staged_analysis(http, log_text=log_text)
 
 
-async def perform_staged_analysis(log_text: str) -> StagedResponse:
+async def perform_staged_analysis(
+    http: aiohttp.ClientSession, log_text: str
+) -> StagedResponse:
     """Submit the log file snippets to the LLM and retrieve their results"""
     log_summary = mine_logs(log_text)
 
@@ -341,6 +366,7 @@ async def perform_staged_analysis(log_text: str) -> StagedResponse:
     analyzed_snippets = await asyncio.gather(
         *[
             submit_text(
+                http,
                 PROMPT_CONFIG.snippet_prompt_template.format(s),
                 model=SERVER_CONFIG.inference.model,
                 max_tokens=SERVER_CONFIG.inference.max_tokens,
@@ -358,6 +384,7 @@ async def perform_staged_analysis(log_text: str) -> StagedResponse:
     )
 
     final_analysis = await submit_text(
+        http,
         final_prompt,
         model=SERVER_CONFIG.inference.model,
         max_tokens=SERVER_CONFIG.inference.max_tokens,
@@ -385,14 +412,16 @@ async def perform_staged_analysis(log_text: str) -> StagedResponse:
 
 @app.post("/analyze/stream", response_class=StreamingResponse)
 @track_request()
-async def analyze_log_stream(build_log: BuildLog):
+async def analyze_log_stream(
+    build_log: BuildLog, http: aiohttp.ClientSession = Depends(get_http_session)
+):
     """Stream response endpoint for Logdetective.
     Request must be in form {"url":"<YOUR_URL_HERE>"}.
     URL must be valid for the request to be passed to the LLM server.
     Meaning that it must contain appropriate scheme, path and netloc,
     while lacking  result, params or query fields.
     """
-    log_text = process_url(build_log.url)
+    log_text = await process_url(http, build_log.url)
     log_summary = mine_logs(log_text)
     log_summary = format_snippets(log_summary)
     headers = {"Content-Type": "application/json"}
@@ -401,7 +430,10 @@ async def analyze_log_stream(build_log: BuildLog):
         headers["Authorization"] = f"Bearer {SERVER_CONFIG.inference.api_token}"
 
     stream = await submit_text_chat_completions(
-        PROMPT_CONFIG.prompt_template.format(log_summary), stream=True, headers=headers,
+        http,
+        PROMPT_CONFIG.prompt_template.format(log_summary),
+        stream=True,
+        headers=headers,
         model=SERVER_CONFIG.inference.model,
         max_tokens=SERVER_CONFIG.inference.max_tokens,
     )
@@ -411,31 +443,28 @@ async def analyze_log_stream(build_log: BuildLog):
 
 @app.post("/webhook/gitlab/job_events")
 async def receive_gitlab_job_event_webhook(
-    job_hook: JobHook, background_tasks: BackgroundTasks
+    job_hook: JobHook,
+    background_tasks: BackgroundTasks,
+    http: aiohttp.ClientSession = Depends(get_http_session),
 ):
     """Webhook endpoint for receiving job_events notifications from GitLab
     https://docs.gitlab.com/user/project/integrations/webhook_events/#job-events
     lists the full specification for the messages sent for job events."""
 
     # Handle the message in the background so we can return 200 immediately
-    background_tasks.add_task(process_gitlab_job_event, job_hook)
+    background_tasks.add_task(process_gitlab_job_event, http, job_hook)
 
     # No return value or body is required for a webhook.
     # 204: No Content
     return BasicResponse(status_code=204)
 
 
-async def process_gitlab_job_event(job_hook):
+async def process_gitlab_job_event(http: aiohttp.ClientSession, job_hook):
     """Handle a received job_event webhook from GitLab"""
     LOG.debug("Received webhook message:\n%s", job_hook)
 
     # Look up the project this job belongs to
     project = await asyncio.to_thread(app.gitlab_conn.projects.get, job_hook.project_id)
-
-    # check if this project is on the opt-in list
-    if project.name not in SERVER_CONFIG.general.packages:
-        LOG.info("Ignoring unrecognized package %s", project.name)
-        return
     LOG.info("Processing failed job for %s", project.name)
 
     # Retrieve data about the job from the GitLab API
@@ -466,16 +495,21 @@ async def process_gitlab_job_event(job_hook):
     LOG.debug("Retrieving log artifacts")
     # Retrieve the build logs from the merge request artifacts and preprocess them
     try:
-        log_url, preprocessed_log = await retrieve_and_preprocess_koji_logs(job)
+        log_url, preprocessed_log = await retrieve_and_preprocess_koji_logs(http, job)
     except LogsTooLargeError:
         LOG.error("Could not retrieve logs. Too large.")
         raise
 
     # Submit log to Log Detective and await the results.
     log_text = preprocessed_log.read().decode(encoding="utf-8")
-    staged_response = await perform_staged_analysis(log_text=log_text)
+    staged_response = await perform_staged_analysis(http, log_text=log_text)
     preprocessed_log.close()
 
+    # check if this project is on the opt-in list for posting comments.
+    if project.name not in SERVER_CONFIG.general.packages:
+        LOG.info("Not publishing comment for unrecognized package %s", project.name)
+        return
+
     # Add the Log Detective response as a comment to the merge request
     await comment_on_mr(project, merge_request_iid, job, log_url, staged_response)
 
@@ -484,7 +518,9 @@ class LogsTooLargeError(RuntimeError):
     """The log archive exceeds the configured maximum size"""
 
 
-async def retrieve_and_preprocess_koji_logs(job: gitlab.v4.objects.ProjectJob):
+async def retrieve_and_preprocess_koji_logs(
+    http: aiohttp.ClientSession, job: gitlab.v4.objects.ProjectJob
+):
     """Download logs from the merge request artifacts
 
     This function will retrieve the build logs and do some minimal
@@ -495,7 +531,7 @@ async def retrieve_and_preprocess_koji_logs(job: gitlab.v4.objects.ProjectJob):
     Detective. The calling function is responsible for closing this object."""
 
     # Make sure the file isn't too large to process.
-    if not await check_artifacts_file_size(job):
+    if not await check_artifacts_file_size(http, job):
         raise LogsTooLargeError(
             f"Oversized logs for job {job.id} in project {job.project_id}"
         )
@@ -584,21 +620,28 @@ async def retrieve_and_preprocess_koji_logs(job: gitlab.v4.objects.ProjectJob):
     return log_url, artifacts_zip.open(log_path)
 
 
-async def check_artifacts_file_size(job):
+async def check_artifacts_file_size(http: aiohttp.ClientSession, job):
     """Method to determine if the artifacts are too large to process"""
     # First, make sure that the artifacts are of a reasonable size. The
     # zipped artifact collection will be stored in memory below. The
     # python-gitlab library doesn't expose a way to check this value directly,
     # so we need to interact with directly with the headers.
     artifacts_url = f"{SERVER_CONFIG.gitlab.api_url}/projects/{job.project_id}/jobs/{job.id}/artifacts"  # pylint: disable=line-too-long
-    header_resp = await asyncio.to_thread(
-        requests.head,
-        artifacts_url,
-        allow_redirects=True,
-        headers={"Authorization": f"Bearer {SERVER_CONFIG.gitlab.api_token}"},
-        timeout=(3.07, 5),
-    )
-    content_length = int(header_resp.headers.get("content-length"))
+    LOG.debug("checking artifact URL %s", artifacts_url)
+    try:
+        head_response = await http.head(
+            artifacts_url,
+            allow_redirects=True,
+            headers={"Authorization": f"Bearer {SERVER_CONFIG.gitlab.api_token}"},
+            timeout=5,
+            raise_for_status=True,
+        )
+    except aiohttp.ClientResponseError as ex:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Unable to check artifact URL: [{ex.status}] {ex.message}",
+        ) from ex
+    content_length = int(head_response.headers.get("content-length"))
     LOG.debug(
         "URL: %s, content-length: %d, max length: %d",
         artifacts_url,

logdetective/utils.py

@@ -2,8 +2,9 @@ import logging
 import os
 from typing import Iterator, List, Dict, Tuple, Generator
 from urllib.parse import urlparse
+
+import aiohttp
 import numpy as np
-import requests
 import yaml
 
 from llama_cpp import Llama, CreateCompletionResponse, CreateCompletionStreamResponse
@@ -133,7 +134,24 @@ def process_log(
     return response
 
 
-def retrieve_log_content(log_path: str) -> str:
+async def get_url_content(http: aiohttp.ClientSession, url: str, timeout: int) -> str:
+    """validate log url and return log text."""
+    if validate_url(url=url):
+        LOG.debug("process url %s", url)
+        try:
+            response = await http.get(
+                url,
+                timeout=timeout,
+                raise_for_status=True
+            )
+        except aiohttp.ClientResponseError as ex:
+            raise RuntimeError(f"We couldn't obtain the logs: {ex}") from ex
+        return await response.text()
+    LOG.error("Invalid URL received ")
+    raise RuntimeError(f"Invalid log URL: {url}")
+
+
+async def retrieve_log_content(http: aiohttp.ClientSession, log_path: str) -> str:
     """Get content of the file on the log_path path.
     Path is assumed to be valid URL if it has a scheme.
     Otherwise it attempts to pull it from local filesystem."""
@@ -148,7 +166,7 @@ def retrieve_log_content(log_path: str) -> str:
             log = f.read()
 
     else:
-        log = requests.get(log_path, timeout=60).text
+        log = await get_url_content(http, log_path, timeout=60)
 
     return log
 

{logdetective-0.5.11.dist-info → logdetective-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: logdetective
-Version: 0.5.11
+Version: 0.6.0
 Summary: Log using LLM AI to search for build/test failures and provide ideas for fixing these.
 License: Apache-2.0
 Author: Jiri Podivin
@@ -20,6 +20,7 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Debuggers
 Provides-Extra: server
 Provides-Extra: server-testing
+Requires-Dist: aiohttp (>=3.7.4)
 Requires-Dist: alembic (>=1.13.3,<2.0.0) ; extra == "server" or extra == "server-testing"
 Requires-Dist: drain3 (>=0.9.11,<0.10.0)
 Requires-Dist: fastapi (>=0.111.1) ; extra == "server" or extra == "server-testing"
@@ -32,7 +33,6 @@ Requires-Dist: psycopg2-binary (>=2.9.9,<3.0.0) ; extra == "server-testing"
 Requires-Dist: pydantic (>=2.8.2,<3.0.0)
 Requires-Dist: python-gitlab (>=4.4.0)
 Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
-Requires-Dist: requests (>0.2.31)
 Requires-Dist: sqlalchemy (>=2.0.36,<3.0.0) ; extra == "server" or extra == "server-testing"
 Project-URL: homepage, https://github.com/fedora-copr/logdetective
 Project-URL: issues, https://github.com/fedora-copr/logdetective/issues

{logdetective-0.5.11.dist-info → logdetective-0.6.0.dist-info}/RECORD

@@ -2,7 +2,7 @@ logdetective/__init__.py,sha256=VqRngDcuFT7JWms8Qc_MsOvajoXVOKPr-S1kqY3Pqhc,59
 logdetective/constants.py,sha256=A5PzeqlQqDbBS_kzP2hl-lhJ0lCEqdbvW3CaQUYVxjw,1849
 logdetective/drain3.ini,sha256=ni91eCT1TwTznZwcqWoOVMQcGEnWhEDNCoTPF7cfGfY,1360
 logdetective/extractors.py,sha256=7ahzWbTtU9MveG1Q7wU9LO8OJgs85X-cHmWltUhCe9M,3491
-logdetective/logdetective.py,sha256=Q1SfQ9sWR5sIvHJag61-F-8edwf7p1SV7QZRg9VaWcc,5604
+logdetective/logdetective.py,sha256=cC2oL4yPNo94AB2nS4v1jpZi-Qo1g0_FEchL_yQL1UU,5832
 logdetective/models.py,sha256=nrGBmMRu8i6UhFflQKAp81Y3Sd_Aaoor0i_yqSJoLT0,1115
 logdetective/prompts.yml,sha256=dMW2-bdTIqv7LF_owqRD4xinMK5ZWcNhDynnX1zoKns,1722
 logdetective/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -12,13 +12,13 @@ logdetective/server/database/models.py,sha256=m_3qNBWJwLSwjJn0AmwSxXMJk75Gu1bXFt
 logdetective/server/metric.py,sha256=-uM_-yqxNA-EZTCnNRdQ8g1MicmE5eC6jRFI_mBBYUg,2606
 logdetective/server/models.py,sha256=URqZcfx5yUsifZ1pOwZ_uU3Tyjcdvuq6qEnAvTexl4A,8475
 logdetective/server/plot.py,sha256=B2rOngqx7g-Z3NfttboTip3frkypdF1H7FhK8vh45mE,9655
-logdetective/server/server.py,sha256=4NylBojHm9E3gjByVWs870T204ls39EbZmUfU0Kyq4U,28395
+logdetective/server/server.py,sha256=AXduOwD6zPNFc-COw-JcTp4bPan9DfXJml52XiBHmds,29613
 logdetective/server/templates/gitlab_full_comment.md.j2,sha256=DQZ2WVFedpuXI6znbHIW4wpF9BmFS8FaUkowh8AnGhE,1627
 logdetective/server/templates/gitlab_short_comment.md.j2,sha256=fzScpayv2vpRLczP_0O0YxtA8rsKvR6gSv4ntNdWb98,1443
 logdetective/server/utils.py,sha256=QO0H1q55YLCLKxkViqex4Uu31LnakpYUKJfZHysonSc,1838
-logdetective/utils.py,sha256=nklnTipAet9P9aEiuHcnK62WT0DmNHbvO1TvNlrxlik,6463
-logdetective-0.5.11.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-logdetective-0.5.11.dist-info/METADATA,sha256=LOOzu99kJaP02U2OaFQciPdWKhlgr4Vm4tVKijTY7NM,15882
-logdetective-0.5.11.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-logdetective-0.5.11.dist-info/entry_points.txt,sha256=3K_vXja6PmcA8sNdUi63WdImeiNhVZcEGPTaoJmltfA,63
-logdetective-0.5.11.dist-info/RECORD,,
+logdetective/utils.py,sha256=IBAH6hleuhtbA3cAGhiIDb3zwKaovunBfVsG0TKzoKA,7127
+logdetective-0.6.0.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+logdetective-0.6.0.dist-info/METADATA,sha256=zBYLi3jNjqR-6EYJY4wy5CS-1-ZgEzzRGofcqzXbHco,15880
+logdetective-0.6.0.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+logdetective-0.6.0.dist-info/entry_points.txt,sha256=3K_vXja6PmcA8sNdUi63WdImeiNhVZcEGPTaoJmltfA,63
+logdetective-0.6.0.dist-info/RECORD,,