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

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,46 +160,46 @@ 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,
     stream: bool = False,
     model: str = "default-model",
-    api_endpoint: str = "/chat/completions",
 ) -> Explanation:
     """Submit prompt to LLM using a selected endpoint.
     max_tokens: number of tokens to be produces, 0 indicates run until encountering EOS
@@ -199,16 +212,17 @@ async def submit_text(  # pylint: disable=R0913,R0917
     if SERVER_CONFIG.inference.api_token:
         headers["Authorization"] = f"Bearer {SERVER_CONFIG.inference.api_token}"
 
-    if api_endpoint == "/chat/completions":
+    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,
@@ -227,9 +241,11 @@ async def submit_text_completions(  # pylint: disable=R0913,R0917
         "logprobs": log_probs,
         "stream": stream,
         "model": model,
+        "temperature": SERVER_CONFIG.inference.temperature,
     }
 
     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,
@@ -266,9 +283,11 @@ async def submit_text_chat_completions(  # pylint: disable=R0913,R0917
         "logprobs": log_probs,
         "stream": stream,
         "model": model,
+        "temperature": SERVER_CONFIG.inference.temperature,
     }
 
     response = await submit_to_llm_endpoint(
+        http,
         f"{SERVER_CONFIG.inference.url}/v1/chat/completions",
         data,
         headers,
@@ -288,19 +307,23 @@ 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),
-        api_endpoint=SERVER_CONFIG.inference.api_endpoint,
+        model=SERVER_CONFIG.inference.model,
+        max_tokens=SERVER_CONFIG.inference.max_tokens,
     )
     certainty = 0
 
@@ -319,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)
 
@@ -339,8 +366,10 @@ async def perform_staged_analysis(log_text: str) -> StagedResponse:
     analyzed_snippets = await asyncio.gather(
         *[
             submit_text(
+                http,
                 PROMPT_CONFIG.snippet_prompt_template.format(s),
-                api_endpoint=SERVER_CONFIG.inference.api_endpoint,
+                model=SERVER_CONFIG.inference.model,
+                max_tokens=SERVER_CONFIG.inference.max_tokens,
             )
             for s in log_summary
         ]
@@ -355,7 +384,10 @@ async def perform_staged_analysis(log_text: str) -> StagedResponse:
     )
 
     final_analysis = await submit_text(
-        final_prompt, api_endpoint=SERVER_CONFIG.inference.api_endpoint
+        http,
+        final_prompt,
+        model=SERVER_CONFIG.inference.model,
+        max_tokens=SERVER_CONFIG.inference.max_tokens,
     )
 
     certainty = 0
@@ -380,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"}
@@ -396,7 +430,12 @@ 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,
     )
 
     return StreamingResponse(stream)
@@ -404,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
@@ -459,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)
 
@@ -477,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
@@ -488,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}"
         )
@@ -577,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,
@@ -616,8 +666,8 @@ async def comment_on_mr(
         response.explanation.text,
     )
 
-    # Get the formatted comment.
-    comment = await generate_mr_comment(job, log_url, response)
+    # Get the formatted short comment.
+    short_comment = await generate_mr_comment(job, log_url, response, full=False)
 
     # Look up the merge request
     merge_request = await asyncio.to_thread(
@@ -625,11 +675,33 @@ async def comment_on_mr(
     )
 
     # Submit a new comment to the Merge Request using the Gitlab API
-    await asyncio.to_thread(merge_request.discussions.create, {"body": comment})
+    discussion = await asyncio.to_thread(
+        merge_request.discussions.create, {"body": short_comment}
+    )
+
+    # Get the ID of the first note
+    note_id = discussion.attributes["notes"][0]["id"]
+    note = discussion.notes.get(note_id)
+
+    # Update the comment with the full details
+    # We do this in a second step so we don't bombard the user's email
+    # notifications with a massive message. Gitlab doesn't send email for
+    # comment edits.
+    full_comment = await generate_mr_comment(job, log_url, response, full=True)
+    note.body = full_comment
+
+    # Pause for five seconds before sending the snippet data, otherwise
+    # Gitlab may bundle the edited message together with the creation
+    # message in email.
+    await asyncio.sleep(5)
+    await asyncio.to_thread(note.save)
 
 
 async def generate_mr_comment(
-    job: gitlab.v4.objects.ProjectJob, log_url: str, response: StagedResponse
+    job: gitlab.v4.objects.ProjectJob,
+    log_url: str,
+    response: StagedResponse,
+    full: bool = True,
 ) -> str:
     """Use a template to generate a comment string to submit to Gitlab"""
 
@@ -637,7 +709,11 @@ async def generate_mr_comment(
     script_path = Path(__file__).resolve().parent
     template_path = Path(script_path, "templates")
     jinja_env = jinja2.Environment(loader=jinja2.FileSystemLoader(template_path))
-    tpl = jinja_env.get_template("gitlab_comment.md.j2")
+
+    if full:
+        tpl = jinja_env.get_template("gitlab_full_comment.md.j2")
+    else:
+        tpl = jinja_env.get_template("gitlab_short_comment.md.j2")
 
     artifacts_url = f"{job.project_url}/-/jobs/{job.id}/artifacts/download"
 
@@ -676,6 +752,35 @@ def _svg_figure_response(fig: matplotlib.figure.Figure):
     )
 
 
+def _multiple_svg_figures_response(figures: list[matplotlib.figure.Figure]):
+    """Create a response with multiple svg figures."""
+    svg_contents = []
+    for i, fig in enumerate(figures):
+        buf = BytesIO()
+        fig.savefig(buf, format="svg", bbox_inches="tight")
+        matplotlib.pyplot.close(fig)
+        buf.seek(0)
+        svg_contents.append(buf.read().decode("utf-8"))
+
+    html_content = "<html><body>\n"
+    for i, svg in enumerate(svg_contents):
+        html_content += f"<div id='figure-{i}'>\n{svg}\n</div>\n"
+    html_content += "</body></html>"
+
+    return BasicResponse(content=html_content, media_type="text/html")
+
+
+@app.get("/metrics/analyze", response_class=StreamingResponse)
+async def show_analyze_metrics(period_since_now: TimePeriod = Depends(TimePeriod)):
+    """Show statistics for requests and responses in the given period of time
+    for the /analyze API endpoint."""
+    fig_requests = plot.requests_per_time(period_since_now, EndpointType.ANALYZE)
+    fig_responses = plot.average_time_per_responses(
+        period_since_now, EndpointType.ANALYZE
+    )
+    return _multiple_svg_figures_response([fig_requests, fig_responses])
+
+
 @app.get("/metrics/analyze/requests", response_class=StreamingResponse)
 async def show_analyze_requests(period_since_now: TimePeriod = Depends(TimePeriod)):
     """Show statistics for the requests received in the given period of time
@@ -684,6 +789,27 @@ async def show_analyze_requests(period_since_now: TimePeriod = Depends(TimePerio
     return _svg_figure_response(fig)
 
 
+@app.get("/metrics/analyze/responses", response_class=StreamingResponse)
+async def show_analyze_responses(period_since_now: TimePeriod = Depends(TimePeriod)):
+    """Show statistics for responses given in the specified period of time
+    for the /analyze API endpoint."""
+    fig = plot.average_time_per_responses(period_since_now, EndpointType.ANALYZE)
+    return _svg_figure_response(fig)
+
+
+@app.get("/metrics/analyze/staged", response_class=StreamingResponse)
+async def show_analyze_staged_metrics(
+    period_since_now: TimePeriod = Depends(TimePeriod),
+):
+    """Show statistics for requests and responses in the given period of time
+    for the /analyze/staged API endpoint."""
+    fig_requests = plot.requests_per_time(period_since_now, EndpointType.ANALYZE_STAGED)
+    fig_responses = plot.average_time_per_responses(
+        period_since_now, EndpointType.ANALYZE_STAGED
+    )
+    return _multiple_svg_figures_response([fig_requests, fig_responses])
+
+
 @app.get("/metrics/analyze/staged/requests", response_class=StreamingResponse)
 async def show_analyze_staged_requests(
     period_since_now: TimePeriod = Depends(TimePeriod),
@@ -692,3 +818,13 @@ async def show_analyze_staged_requests(
     for the /analyze/staged API endpoint."""
     fig = plot.requests_per_time(period_since_now, EndpointType.ANALYZE_STAGED)
     return _svg_figure_response(fig)
+
+
+@app.get("/metrics/analyze/staged/responses", response_class=StreamingResponse)
+async def show_analyze_staged_responses(
+    period_since_now: TimePeriod = Depends(TimePeriod),
+):
+    """Show statistics for responses given in the specified period of time
+    for the /analyze/staged API endpoint."""
+    fig = plot.average_time_per_responses(period_since_now, EndpointType.ANALYZE_STAGED)
+    return _svg_figure_response(fig)

logdetective/server/templates/{gitlab_comment.md.j2 → gitlab_full_comment.md.j2}

@@ -9,9 +9,7 @@ In this case, we are {{ certainty }}% certain of the response {{ emoji_face }}.
 <ul>
 {% for snippet in snippets %}
 <li>
-<code>
-Line {{ snippet.line_number }}: {{ snippet.text }}
-</code>
+<b>Line {{ snippet.line_number }}:</b> <code>{{ snippet.text }}</code>
 {{ snippet.explanation }}
 </li>
 {% endfor %}

logdetective/server/templates/gitlab_short_comment.md.j2

@@ -0,0 +1,53 @@
+The package {{ package }} failed to build, here is a possible explanation why.
+
+Please know that the explanation was provided by AI and may be incorrect.
+In this case, we are {{ certainty }}% certain of the response {{ emoji_face }}.
+
+{{ explanation }}
+
+<details>
+  <summary>Logs</summary>
+  <p>
+    Log Detective analyzed the following logs files to provide an explanation:
+  </p>
+
+  <ul>
+    <li><a href="{{ log_url }}">{{ log_url }}</a></li>
+  </ul>
+
+  <p>
+    Additional logs are available from:
+    <ul>
+    <li><a href="{{ artifacts_url }}">artifacts.zip</a></li>
+  </ul>
+  </p>
+
+  <p>
+    Please know that these log files are automatically removed after some
+    time, so you might need a backup.
+  </p>
+</details>
+
+<details>
+  <summary>Help</summary>
+  <p>Don't hesitate to reach out.</p>
+
+  <ul>
+    <li><a href="https://github.com/fedora-copr/logdetective">Upstream</a></li>
+    <li><a href="https://github.com/fedora-copr/logdetective/issues">Issue tracker</a></li>
+    <li><a href="https://redhat.enterprise.slack.com/archives/C06DWNVKKDE">Slack</a></li>
+    <li><a href="https://log-detective.com/documentation">Documentation</a></li>
+  </ul>
+</details>
+
+
+---
+This comment was created by [Log Detective][log-detective].
+
+Was the provided feedback accurate and helpful? <br>Please vote with :thumbsup:
+or :thumbsdown: to help us improve.<br>
+
+
+
+[log-detective]: https://log-detective.com/
+[contact]: https://github.com/fedora-copr