logdetective 1.6.0__tar.gz → 1.7.0__tar.gz

{logdetective-1.6.0 → logdetective-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: logdetective
-Version: 1.6.0
+Version: 1.7.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
@@ -331,7 +331,7 @@ If the variable is not set, `./models` is mounted inside by default.
 
 Model can be downloaded from [our Hugging Space](https://huggingface.co/fedora-copr) by:
 ```
-$ curl -L -o models/mistral-7b-instruct-v0.2.Q4_K_S.gguf https://huggingface.co/fedora-copr/Mistral-7B-Instruct-v0.2-GGUF/resolve/main/ggml-model-Q4_K_S.gguf
+$ curl -L -o models/mistral-7b-instruct-v0.3.Q4_K.gguf https://huggingface.co/fedora-copr/Mistral-7B-Instruct-v0.3-GGUF/resolve/main/ggml-model-Q4_K.gguf
 ```
 
 Generate a new database revision with alembic

{logdetective-1.6.0 → logdetective-1.7.0}/README.md

@@ -287,7 +287,7 @@ If the variable is not set, `./models` is mounted inside by default.
 
 Model can be downloaded from [our Hugging Space](https://huggingface.co/fedora-copr) by:
 ```
-$ curl -L -o models/mistral-7b-instruct-v0.2.Q4_K_S.gguf https://huggingface.co/fedora-copr/Mistral-7B-Instruct-v0.2-GGUF/resolve/main/ggml-model-Q4_K_S.gguf
+$ curl -L -o models/mistral-7b-instruct-v0.3.Q4_K.gguf https://huggingface.co/fedora-copr/Mistral-7B-Instruct-v0.3-GGUF/resolve/main/ggml-model-Q4_K.gguf
 ```
 
 Generate a new database revision with alembic

{logdetective-1.6.0 → logdetective-1.7.0}/logdetective/constants.py

@@ -4,7 +4,7 @@ in prompts.yaml instead.
 """
 
 # pylint: disable=line-too-long
-DEFAULT_ADVISOR = "fedora-copr/Mistral-7B-Instruct-v0.2-GGUF"
+DEFAULT_ADVISOR = "fedora-copr/Mistral-7B-Instruct-v0.3-GGUF"
 
 PROMPT_TEMPLATE = """
 Given following log snippets, and nothing else, explain what failure, if any, occured during build of this package.

{logdetective-1.6.0 → logdetective-1.7.0}/logdetective/logdetective.py

@@ -42,7 +42,7 @@ def setup_args():
         "--filename_suffix",
         help="Suffix of the model file name to be retrieved from Hugging Face.\
                             Makes sense only if the model is specified with Hugging Face name.",
-        default="Q4_K_S.gguf",
+        default="Q4_K.gguf",
     )
     parser.add_argument("-n", "--no-stream", action="store_true")
     parser.add_argument(

{logdetective-1.6.0 → logdetective-1.7.0}/logdetective/server/database/models/__init__.py

@@ -5,10 +5,18 @@ from logdetective.server.database.models.merge_request_jobs import (
     Comments,
     Reactions,
 )
+from logdetective.server.database.models.koji import (
+    KojiTaskAnalysis,
+)
 from logdetective.server.database.models.metrics import (
     AnalyzeRequestMetrics,
     EndpointType,
 )
+from logdetective.server.database.models.exceptions import (
+    KojiTaskNotFoundError,
+    KojiTaskNotAnalyzedError,
+    KojiTaskAnalysisTimeoutError,
+)
 
 __all__ = [
     Base.__name__,
@@ -18,4 +26,8 @@ __all__ = [
     AnalyzeRequestMetrics.__name__,
     EndpointType.__name__,
     Forge.__name__,
+    KojiTaskAnalysis.__name__,
+    KojiTaskNotFoundError.__name__,
+    KojiTaskNotAnalyzedError.__name__,
+    KojiTaskAnalysisTimeoutError.__name__,
 ]

logdetective-1.7.0/logdetective/server/database/models/exceptions.py

@@ -0,0 +1,13 @@
+"""Database model exceptions for logdetective."""
+
+
+class KojiTaskNotFoundError(Exception):
+    """Exception raised when a koji task is not found"""
+
+
+class KojiTaskNotAnalyzedError(Exception):
+    """Exception raised when a koji task analysis is still in progress"""
+
+
+class KojiTaskAnalysisTimeoutError(Exception):
+    """Exception raised when a koji task analysis has timed out"""

logdetective-1.7.0/logdetective/server/database/models/koji.py

@@ -0,0 +1,126 @@
+from datetime import datetime, timedelta, timezone
+from sqlalchemy import Column, BigInteger, DateTime, ForeignKey, Integer, String
+from sqlalchemy.orm import relationship
+from sqlalchemy.exc import OperationalError
+import backoff
+
+from logdetective.server.config import SERVER_CONFIG
+from logdetective.server.compressors import LLMResponseCompressor
+from logdetective.server.database.models.metrics import AnalyzeRequestMetrics
+from logdetective.server.database.base import Base, transaction, DB_MAX_RETRIES
+from logdetective.server.database.models.exceptions import (
+    KojiTaskNotFoundError,
+    KojiTaskNotAnalyzedError,
+    KojiTaskAnalysisTimeoutError,
+)
+from logdetective.server.models import KojiStagedResponse
+
+
+class KojiTaskAnalysis(Base):
+    """Store details for the koji task analysis"""
+
+    __tablename__ = "koji_task_analysis"
+
+    id = Column(Integer, primary_key=True)
+    koji_instance = Column(String(255), nullable=False, index=True)
+    task_id = Column(BigInteger, nullable=False, index=True, unique=True)
+    log_file_name = Column(String(255), nullable=False, index=True)
+    request_received_at = Column(
+        DateTime,
+        nullable=False,
+        index=True,
+        default=datetime.now(timezone.utc),
+        comment="Timestamp when the request was received",
+    )
+    response_id = Column(
+        Integer,
+        ForeignKey("analyze_request_metrics.id"),
+        nullable=True,
+        index=False,
+        comment="The id of the analyze request metrics for this task",
+    )
+    response = relationship("AnalyzeRequestMetrics")
+
+    @classmethod
+    @backoff.on_exception(backoff.expo, OperationalError, max_tries=DB_MAX_RETRIES)
+    def create_or_restart(cls, koji_instance: str, task_id: int, log_file_name: str):
+        """Create a new koji task analysis"""
+        with transaction(commit=True) as session:
+            # Check if the task analysis already exists
+            koji_task_analysis = (
+                session.query(cls)
+                .filter_by(koji_instance=koji_instance, task_id=task_id)
+                .first()
+            )
+            if koji_task_analysis:
+                # If it does, update the request_received_at timestamp
+                koji_task_analysis.request_received_at = datetime.now(timezone.utc)
+                session.add(koji_task_analysis)
+                session.flush()
+                return
+
+            # If it doesn't, create a new one
+            koji_task_analysis = KojiTaskAnalysis()
+            koji_task_analysis.koji_instance = koji_instance
+            koji_task_analysis.task_id = task_id
+            koji_task_analysis.log_file_name = log_file_name
+            session.add(koji_task_analysis)
+            session.flush()
+
+    @classmethod
+    @backoff.on_exception(backoff.expo, OperationalError, max_tries=DB_MAX_RETRIES)
+    def add_response(cls, task_id: int, metric_id: int):
+        """Add a response to a koji task analysis"""
+        with transaction(commit=True) as session:
+            koji_task_analysis = session.query(cls).filter_by(task_id=task_id).first()
+            # Ensure that the task analysis doesn't already have a response
+            if koji_task_analysis.response:
+                # This is probably due to an analysis that took so long that
+                # a follow-up analysis was started before this one completed.
+                # We want to maintain consistency between the response we
+                # returned to the consumer, so we'll just drop this extra one
+                # on the floor and keep the one saved in the database.
+                return
+
+            metric = (
+                session.query(AnalyzeRequestMetrics).filter_by(id=metric_id).first()
+            )
+            koji_task_analysis.response = metric
+            session.add(koji_task_analysis)
+            session.flush()
+
+    @classmethod
+    @backoff.on_exception(backoff.expo, OperationalError, max_tries=DB_MAX_RETRIES)
+    def get_response_by_task_id(cls, task_id: int) -> KojiStagedResponse:
+        """Get a koji task analysis by task id"""
+        with transaction(commit=False) as session:
+            koji_task_analysis = session.query(cls).filter_by(task_id=task_id).first()
+            if not koji_task_analysis:
+                raise KojiTaskNotFoundError(f"Task {task_id} not yet analyzed")
+
+            if not koji_task_analysis.response:
+                # Check if the task analysis has timed out
+                if koji_task_analysis.request_received_at.replace(
+                    tzinfo=timezone.utc
+                ) + timedelta(
+                    minutes=SERVER_CONFIG.koji.analysis_timeout
+                ) < datetime.now(timezone.utc):
+                    raise KojiTaskAnalysisTimeoutError(
+                        f"Task {task_id} analysis has timed out"
+                    )
+
+                # Task analysis is still in progress, so we need to let the
+                # consumer know
+                raise KojiTaskNotAnalyzedError(
+                    f"Task {task_id} analysis is still in progress"
+                )
+
+            # We need to decompress the response message and return it
+            response = LLMResponseCompressor.unzip(
+                koji_task_analysis.response.compressed_response
+            )
+            return KojiStagedResponse(
+                task_id=task_id,
+                log_file_name=koji_task_analysis.log_file_name,
+                response=response,
+            )

{logdetective-1.6.0 → logdetective-1.7.0}/logdetective/server/database/models/merge_request_jobs.py

@@ -1,6 +1,6 @@
 import enum
 import datetime
-from typing import Optional, List, Tuple
+from typing import Optional, List, Tuple, Self
 
 import backoff
 
@@ -15,6 +15,7 @@ from sqlalchemy import (
     desc,
 )
 from sqlalchemy.orm import relationship
+from sqlalchemy.engine import Row
 from sqlalchemy.exc import OperationalError
 from logdetective.server.database.base import Base, transaction, DB_MAX_RETRIES
 
@@ -134,7 +135,7 @@ class GitlabMergeRequestJobs(Base):
     @classmethod
     def get_by_mr_iid(
         cls, forge: Forge, project_id: int, mr_iid
-    ) -> Optional["GitlabMergeRequestJobs"]:
+    ) -> List[Self]:
         """Get all the mr jobs saved for the specified mr iid and project id."""
         with transaction(commit=False) as session:
             comments = (
@@ -262,7 +263,7 @@ class Comments(Base):
         cls,
         forge: Forge,
         comment_id: str,
-    ) -> Optional["Comments"]:
+    ) -> Optional[Self]:
         """Search for a detailed comment
         by its unique forge comment id.
 
@@ -324,7 +325,7 @@ class Comments(Base):
         forge: Forge,
         project_id: int,
         mr_iid: int,
-    ) -> Optional["Comments"]:
+    ) -> List[Self]:
         """Search for all merge request comments.
 
         Args:
@@ -358,7 +359,7 @@ class Comments(Base):
         mr_iid: int,
         job_id: int,
         comment_id: str,
-    ) -> Optional["Comments"]:
+    ) -> Self:
         """Search for a detailed comment
         or create a new one if not found.
 
@@ -372,11 +373,11 @@ class Comments(Base):
         comment = Comments.get_by_gitlab_id(forge, comment_id)
         if comment is None:
             id_ = Comments.create(forge, project_id, mr_iid, job_id, comment_id)
-            comment = GitlabMergeRequestJobs.get_by_id(id_)
+            comment = Comments.get_by_id(id_)
         return comment
 
     @classmethod
-    def get_since(cls, time: datetime.datetime) -> Optional["Comments"]:
+    def get_since(cls, time: datetime.datetime) -> List[Self]:
         """Get all the comments created after the given time."""
         with transaction(commit=False) as session:
             comments = (
@@ -485,7 +486,7 @@ class Reactions(Base):
         mr_iid: int,
         job_id: int,
         comment_id: str,
-    ) -> int:
+    ) -> List[Self]:
         """Get all reactions for a comment
 
         Args:
@@ -524,7 +525,7 @@ class Reactions(Base):
         job_id: int,
         comment_id: str,
         reaction_type: str,
-    ) -> int:
+    ) -> Self | None:
         """Get reaction, of a given type,
         for a comment
 
@@ -589,7 +590,7 @@ class Reactions(Base):
     @classmethod
     def get_since(
         cls, time: datetime.datetime
-    ) -> List[Tuple[datetime.datetime, "Comments"]]:
+    ) -> List[Row[Tuple[datetime.datetime, Self]]]:
         """Get all the reactions on comments created after the given time
         and the comment creation time."""
         with transaction(commit=False) as session:

{logdetective-1.6.0 → logdetective-1.7.0}/logdetective/server/database/models/metrics.py

@@ -34,6 +34,7 @@ class EndpointType(enum.Enum):
     ANALYZE_STAGED = "analyze_log_staged"
     ANALYZE_STREAM = "analyze_log_stream"
     ANALYZE_GITLAB_JOB = "analyze_gitlab_job"
+    ANALYZE_KOJI_TASK = "analyze_koji_task"
 
 
 class AnalyzeRequestMetrics(Base):

{logdetective-1.6.0 → logdetective-1.7.0}/logdetective/server/emoji.py

@@ -10,6 +10,7 @@ from logdetective.server.database.models import (
     Comments,
     Reactions,
     GitlabMergeRequestJobs,
+    Forge,
 )
 from logdetective.server.config import LOG
 
@@ -19,7 +20,7 @@ async def collect_emojis(gitlab_conn: gitlab.Gitlab, period: TimePeriod):
     Collect emoji feedback from logdetective comments saved in database.
     Check only comments created in the last given period of time.
     """
-    comments = Comments.get_since(period.get_period_start_time())
+    comments = Comments.get_since(period.get_period_start_time()) or []
     comments_for_gitlab_connection = [
         comment for comment in comments if comment.forge == gitlab_conn.url
     ]
@@ -32,7 +33,14 @@ async def collect_emojis_for_mr(
     """
     Collect emoji feedback from logdetective comments in the specified MR.
     """
-    mr_jobs = GitlabMergeRequestJobs.get_by_mr_iid(gitlab_conn.url, project_id, mr_iid)
+    comments = []
+    try:
+        url = Forge(gitlab_conn.url)
+    except ValueError as ex:
+        LOG.exception("Attempt to use unrecognized Forge `%s`", gitlab_conn.url)
+        raise ex
+    mr_jobs = GitlabMergeRequestJobs.get_by_mr_iid(url, project_id, mr_iid) or []
+
     comments = [Comments.get_by_mr_job(mr_job) for mr_job in mr_jobs]
     await collect_emojis_in_comments(comments, gitlab_conn)
 
@@ -63,38 +71,40 @@ async def collect_emojis_in_comments(  # pylint: disable=too-many-locals
     Collect emoji feedback from specified logdetective comments.
     """
     projects = {}
-    mrs = {}
+    merge_requests = {}
     for comment in comments:
         mr_job_db = GitlabMergeRequestJobs.get_by_id(comment.merge_request_job_id)
         if not mr_job_db:
             continue
         if mr_job_db.id not in projects:
-            projects[mr_job_db.id] = project = await _handle_gitlab_operation(
+            project = await _handle_gitlab_operation(
                 gitlab_conn.projects.get, mr_job_db.project_id
             )
             if not project:
                 continue
+            projects[mr_job_db.id] = project
         else:
             project = projects[mr_job_db.id]
-        mr_iid = mr_job_db.mr_iid
-        if mr_iid not in mrs:
-            mrs[mr_iid] = mr = await _handle_gitlab_operation(
-                project.mergerequests.get, mr_iid
+        merge_request_iid = mr_job_db.mr_iid
+        if merge_request_iid not in merge_requests:
+            merge_request = await _handle_gitlab_operation(
+                project.mergerequests.get, merge_request_iid
             )
-            if not mr:
+            if not merge_request:
                 continue
+            merge_requests[merge_request_iid] = merge_request
         else:
-            mr = mrs[mr_iid]
+            merge_request = merge_requests[merge_request_iid]
 
         discussion = await _handle_gitlab_operation(
-            mr.discussions.get, comment.comment_id
+            merge_request.discussions.get, comment.comment_id
         )
         if not discussion:
             continue
 
         # Get the ID of the first note
         note_id = discussion.attributes["notes"][0]["id"]
-        note = await _handle_gitlab_operation(mr.notes.get, note_id)
+        note = await _handle_gitlab_operation(merge_request.notes.get, note_id)
         if not note:
             continue
 

logdetective-1.7.0/logdetective/server/exceptions.py

@@ -0,0 +1,33 @@
+"""Exception classes for Log Detective server."""
+
+
+class LogDetectiveException(Exception):
+    """Base exception for Log Detective server."""
+
+
+class LogsMissingError(LogDetectiveException):
+    """The logs are missing, possibly due to garbage-collection"""
+
+
+class LogDetectiveKojiException(LogDetectiveException):
+    """Base exception for Koji-related errors."""
+
+
+class KojiInvalidTaskID(LogDetectiveKojiException):
+    """The task ID is invalid."""
+
+
+class UnknownTaskType(LogDetectiveKojiException):
+    """The task type is not supported."""
+
+
+class NoFailedTask(LogDetectiveKojiException):
+    """The task is not in the FAILED state."""
+
+
+class LogDetectiveConnectionError(LogDetectiveKojiException):
+    """A connection error occurred."""
+
+
+class LogsTooLargeError(LogDetectiveKojiException):
+    """The log archive exceeds the configured maximum size"""

{logdetective-1.6.0 → logdetective-1.7.0}/logdetective/server/gitlab.py

@@ -13,6 +13,7 @@ import jinja2
 import aiohttp
 
 from logdetective.server.config import SERVER_CONFIG, LOG
+from logdetective.server.exceptions import LogsTooLargeError
 from logdetective.server.llm import perform_staged_analysis
 from logdetective.server.metric import add_new_metrics, update_metrics
 from logdetective.server.models import (
@@ -150,10 +151,6 @@ def is_eligible_package(project_name: str):
     return True
 
 
-class LogsTooLargeError(RuntimeError):
-    """The log archive exceeds the configured maximum size"""
-
-
 async def retrieve_and_preprocess_koji_logs(
     gitlab_cfg: GitLabInstanceConfig,
     job: gitlab.v4.objects.ProjectJob,

logdetective-1.7.0/logdetective/server/koji.py

@@ -0,0 +1,167 @@
+import asyncio
+import re
+from typing import Any, Callable, Optional
+
+import backoff
+import koji
+from logdetective.server.config import LOG
+from logdetective.server.exceptions import (
+    KojiInvalidTaskID,
+    LogDetectiveConnectionError,
+    LogsMissingError,
+    LogsTooLargeError,
+    UnknownTaskType,
+)
+
+
+FAILURE_LOG_REGEX = re.compile(r"(\w*\.log)")
+
+
+def connection_error_giveup(details: backoff._typing.Details) -> None:
+    """
+    Too many connection errors, give up.
+    """
+    LOG.error("Too many connection errors, giving up. %s", details["exception"])
+    raise LogDetectiveConnectionError() from details["exception"]
+
+
+@backoff.on_exception(
+    backoff.expo,
+    koji.GenericError,
+    max_time=60,
+)
+async def call_koji(func: Callable, *args, **kwargs) -> Any:
+    """
+    Call a Koji function asynchronously.
+
+    Automatically retries on connection errors.
+    """
+    try:
+        result = await asyncio.to_thread(func, *args, **kwargs)
+    except koji.ActionNotAllowed as e:
+        # User doesn't have permission to do this, don't retry.
+        raise LogDetectiveConnectionError(e) from e
+    return result
+
+
+async def get_failed_subtask_info(
+    koji_session: koji.ClientSession, task_id: int
+) -> dict[str, Any]:
+    """
+    If the provided task ID represents a task of type "build", this function
+    will return the buildArch or rebuildSRPM subtask that failed. If there is
+    more than one, it will return the first one found from the following
+    ordered list of processor architectures. If none is found among those
+    architectures, it will return the first failed architecture after a
+    standard sort.
+    * x86_64
+    * aarch64
+    * riscv
+    * ppc64le
+    * s390x
+
+    If the provided task ID represents a task of type "buildArch" or
+    "buildSRPMFromSCM" and has a task state of "FAILED", it will be returned
+    directly.
+
+    Any other task type will rase the UnknownTaskType exception.
+
+    If no task or subtask of the provided task is in the task state "FAILED",
+    this function will raise a NoFailedSubtask exception.
+    """
+
+    # Look up the current task first and check its type.
+    taskinfo = await call_koji(koji_session.getTaskInfo, task_id)
+    if not taskinfo:
+        raise KojiInvalidTaskID(f"Task {task_id} does not exist.")
+
+    # If the parent isn't FAILED, the children probably aren't either.
+    # There's one special case where the user may have canceled the
+    # overall task when one arch failed, so we should check that situation
+    # too.
+    if (
+        taskinfo["state"] != koji.TASK_STATES["FAILED"]
+        and taskinfo["state"] != koji.TASK_STATES["CANCELED"]  # noqa: W503 flake vs lint
+    ):
+        raise UnknownTaskType(f"The primary task state was {taskinfo['state']}.")
+
+    # If the task is buildArch or buildSRPMFromSCM, we can return it directly.
+    if taskinfo["method"] in ["buildArch", "buildSRPMFromSCM"]:
+        return taskinfo
+
+    # Look up the subtasks for the task.
+    response = await asyncio.to_thread(koji_session.getTaskDescendents, task_id)
+    subtasks = response[f"{task_id}"]
+    arch_tasks = {}
+    for subtask in subtasks:
+        if (
+            subtask["method"] not in ["buildArch", "buildSRPMFromSCM"]
+            or subtask["state"] != koji.TASK_STATES["FAILED"]  # noqa: W503 flake vs lint
+        ):
+            # Skip over any completed subtasks or non-build types
+            continue
+
+        arch_tasks[subtask["arch"]] = subtask
+
+    # Return the first architecture in the order of preference.
+    for arch in ["x86_64", "aarch64", "riscv", "ppc64le", "s390x"]:
+        if arch in arch_tasks:
+            return arch_tasks[arch]
+
+    # If none of those architectures were found, return the first one
+    # alphabetically
+    return arch_tasks[sorted(arch_tasks.keys())[0]]
+
+
+async def get_failed_log_from_task(
+    koji_session: koji.ClientSession, task_id: int, max_size: int
+) -> Optional[tuple[str, str]]:
+    """
+    Get the failed log from a task.
+
+    If the log is too large, this function will raise a LogsTooLargeError.
+    If the log is missing or garbage-collected, this function will raise a
+    LogsMissingError.
+    """
+    taskinfo = await get_failed_subtask_info(koji_session, task_id)
+
+    # Read the failure reason from the task. Note that the taskinfo returned
+    # above may not be the same as passed in, so we need to use taskinfo["id"]
+    # to look up the correct failure reason.
+    result = await call_koji(
+        koji_session.getTaskResult, taskinfo["id"], raise_fault=False
+    )
+
+    # Examine the result message for the appropriate log file.
+    match = FAILURE_LOG_REGEX.search(result["faultString"])
+    if match:
+        failure_log_name = match.group(1)
+    else:
+        # The best thing we can do at this point is return the
+        # task_failed.log, since it will probably contain the most
+        # relevant information
+        return result["faultString"]
+
+    # Check that the size of the log file is not enormous
+    task_output = await call_koji(
+        koji_session.listTaskOutput, taskinfo["id"], stat=True
+    )
+    if not task_output:
+        # If the task has been garbage-collected, the task output will be empty
+        raise LogsMissingError(
+            "No logs attached to this task. Possibly garbage-collected."
+        )
+
+    if failure_log_name not in task_output:
+        # This shouldn't be possible, but we'll check anyway.
+        raise LogsMissingError(f"{failure_log_name} could not be located")
+
+    if int(task_output[failure_log_name]["st_size"]) > max_size:
+        raise LogsTooLargeError(
+            f"{task_output[failure_log_name]['st_size']} exceeds max size {max_size}"
+        )
+
+    log_contents = await call_koji(
+        koji_session.downloadTaskOutput, taskinfo["id"], failure_log_name
+    )
+    return failure_log_name, log_contents.decode("utf-8")

{logdetective-1.6.0 → logdetective-1.7.0}/logdetective/server/metric.py

@@ -2,7 +2,7 @@ import io
 import inspect
 import datetime
 
-from typing import Union
+from typing import Optional, Union
 from functools import wraps
 
 import aiohttp
@@ -17,10 +17,10 @@ from logdetective.server.database.models import EndpointType, AnalyzeRequestMetr
 
 async def add_new_metrics(
     api_name: str,
-    url: str,
-    http_session: aiohttp.ClientSession,
-    received_at: datetime.datetime = None,
-    compressed_log_content: io.BytesIO = None,
+    url: Optional[str] = None,
+    http_session: Optional[aiohttp.ClientSession] = None,
+    received_at: Optional[datetime.datetime] = None,
+    compressed_log_content: Optional[io.BytesIO] = None,
 ) -> int:
     """Add a new database entry for a received request.
 
@@ -28,10 +28,10 @@ async def add_new_metrics(
     the endpoint from where the request was received,
     and the log (in a zip format) for which analysis is requested.
     """
-    remote_log = RemoteLog(url, http_session)
-    compressed_log_content = (
-        compressed_log_content or await RemoteLogCompressor(remote_log).zip_content()
-    )
+    if not compressed_log_content:
+        remote_log = RemoteLog(url, http_session)
+        compressed_log_content = await RemoteLogCompressor(remote_log).zip_content()
+
     return AnalyzeRequestMetrics.create(
         endpoint=EndpointType(api_name),
         compressed_log=compressed_log_content,
@@ -44,7 +44,7 @@ async def add_new_metrics(
 def update_metrics(
     metrics_id: int,
     response: Union[models.Response, models.StagedResponse, StreamingResponse],
-    sent_at: datetime.datetime = None,
+    sent_at: Optional[datetime.datetime] = None,
 ) -> None:
     """Update a database metric entry for a received request,
     filling data for the given response.

{logdetective-1.6.0 → logdetective-1.7.0}/logdetective/server/models.py

@@ -1,4 +1,5 @@
 import asyncio
+from collections import defaultdict
 import datetime
 from logging import BASIC_FORMAT
 from typing import List, Dict, Optional
@@ -15,6 +16,7 @@ import aiohttp
 
 from aiolimiter import AsyncLimiter
 from gitlab import Gitlab
+import koji
 
 from logdetective.constants import (
     DEFAULT_TEMPERATURE,
@@ -132,6 +134,17 @@ class StagedResponse(Response):
     snippets: List[AnalyzedSnippet]
 
 
+class KojiStagedResponse(BaseModel):
+    """Model of data returned by Log Detective API when called when a Koji build
+    analysis is requested. Contains list of reponses to prompts for individual
+    snippets.
+    """
+
+    task_id: int
+    log_file_name: str
+    response: StagedResponse
+
+
 class InferenceConfig(BaseModel):  # pylint: disable=too-many-instance-attributes
     """Model for inference configuration of logdetective server."""
 
@@ -247,7 +260,7 @@ class GitLabInstanceConfig(BaseModel):  # pylint: disable=too-many-instance-attr
     _http_session: aiohttp.ClientSession = None
 
     # Maximum size of artifacts.zip in MiB. (default: 300 MiB)
-    max_artifact_size: int = 300
+    max_artifact_size: int = 300 * 1024 * 1024
 
     def __init__(self, name: str, data: Optional[dict] = None):
         super().__init__()
@@ -259,7 +272,7 @@ class GitLabInstanceConfig(BaseModel):  # pylint: disable=too-many-instance-attr
         self.api_path = data.get("api_path", "/api/v4")
         self.api_token = data.get("api_token", None)
         self.webhook_secrets = data.get("webhook_secrets", None)
-        self.max_artifact_size = int(data.get("max_artifact_size")) * 1024 * 1024
+        self.max_artifact_size = int(data.get("max_artifact_size", 300)) * 1024 * 1024
 
         self.timeout = data.get("timeout", 5.0)
         self._conn = Gitlab(
@@ -323,6 +336,80 @@ class GitLabConfig(BaseModel):
             self.instances[instance.url] = instance
 
 
+class KojiInstanceConfig(BaseModel):
+    """Model for Koji configuration of logdetective server."""
+
+    name: str = ""
+    xmlrpc_url: str = ""
+    tokens: List[str] = []
+
+    _conn: Optional[koji.ClientSession] = None
+    _callbacks: defaultdict[int, set[str]] = defaultdict(set)
+
+    def __init__(self, name: str, data: Optional[dict] = None):
+        super().__init__()
+
+        self.name = name
+        if data is None:
+            # Set some reasonable defaults
+            self.xmlrpc_url = "https://koji.fedoraproject.org/kojihub"
+            self.tokens = []
+            self.max_artifact_size = 1024 * 1024
+            return
+
+        self.xmlrpc_url = data.get(
+            "xmlrpc_url", "https://koji.fedoraproject.org/kojihub"
+        )
+        self.tokens = data.get("tokens", [])
+
+    def get_connection(self):
+        """Get the Koji connection object"""
+        if not self._conn:
+            self._conn = koji.ClientSession(self.xmlrpc_url)
+        return self._conn
+
+    def register_callback(self, task_id: int, callback: str):
+        """Register a callback for a task"""
+        self._callbacks[task_id].add(callback)
+
+    def clear_callbacks(self, task_id: int):
+        """Unregister a callback for a task"""
+        try:
+            del self._callbacks[task_id]
+        except KeyError:
+            pass
+
+    def get_callbacks(self, task_id: int) -> set[str]:
+        """Get the callbacks for a task"""
+        return self._callbacks[task_id]
+
+
+class KojiConfig(BaseModel):
+    """Model for Koji configuration of logdetective server."""
+
+    instances: Dict[str, KojiInstanceConfig] = {}
+    analysis_timeout: int = 15
+    max_artifact_size: int = 300 * 1024 * 1024
+
+    def __init__(self, data: Optional[dict] = None):
+        super().__init__()
+        if data is None:
+            return
+
+        # Handle analysis_timeout with default 15
+        self.analysis_timeout = data.get("analysis_timeout", 15)
+
+        # Handle max_artifact_size with default 300
+        self.max_artifact_size = data.get("max_artifact_size", 300) * 1024 * 1024
+
+        # Handle instances dictionary
+        instances_data = data.get("instances", {})
+        for instance_name, instance_data in instances_data.items():
+            self.instances[instance_name] = KojiInstanceConfig(
+                instance_name, instance_data
+            )
+
+
 class LogConfig(BaseModel):
     """Logging configuration"""
 
@@ -375,6 +462,7 @@ class Config(BaseModel):
     snippet_inference: InferenceConfig = InferenceConfig()
     extractor: ExtractorConfig = ExtractorConfig()
     gitlab: GitLabConfig = GitLabConfig()
+    koji: KojiConfig = KojiConfig()
     general: GeneralConfig = GeneralConfig()
 
     def __init__(self, data: Optional[dict] = None):
@@ -387,6 +475,7 @@ class Config(BaseModel):
         self.inference = InferenceConfig(data.get("inference"))
         self.extractor = ExtractorConfig(data.get("extractor"))
         self.gitlab = GitLabConfig(data.get("gitlab"))
+        self.koji = KojiConfig(data.get("koji"))
         self.general = GeneralConfig(data.get("general"))
 
         if snippet_inference := data.get("snippet_inference", None):

{logdetective-1.6.0 → logdetective-1.7.0}/logdetective/server/server.py

@@ -8,13 +8,30 @@ from io import BytesIO
 
 import matplotlib
 import matplotlib.pyplot
-from fastapi import FastAPI, HTTPException, BackgroundTasks, Depends, Header, Request
+from fastapi import (
+    FastAPI,
+    HTTPException,
+    BackgroundTasks,
+    Depends,
+    Header,
+    Path,
+    Request,
+)
 
 from fastapi.responses import StreamingResponse
 from fastapi.responses import Response as BasicResponse
 import aiohttp
 import sentry_sdk
 
+from logdetective.server.exceptions import KojiInvalidTaskID
+
+from logdetective.server.database.models.koji import KojiTaskAnalysis
+from logdetective.server.database.models.exceptions import (
+    KojiTaskAnalysisTimeoutError,
+    KojiTaskNotAnalyzedError,
+    KojiTaskNotFoundError,
+)
+
 import logdetective.server.database.base
 
 from logdetective.utils import (
@@ -24,6 +41,9 @@ from logdetective.utils import (
 )
 
 from logdetective.server.config import SERVER_CONFIG, PROMPT_CONFIG, LOG
+from logdetective.server.koji import (
+    get_failed_log_from_task as get_failed_log_from_koji_task,
+)
 from logdetective.remote_log import RemoteLog
 from logdetective.server.llm import (
     mine_logs,
@@ -31,11 +51,13 @@ from logdetective.server.llm import (
     submit_text,
 )
 from logdetective.server.gitlab import process_gitlab_job_event
-from logdetective.server.metric import track_request
+from logdetective.server.metric import track_request, add_new_metrics, update_metrics
 from logdetective.server.models import (
     BuildLog,
     EmojiHook,
     JobHook,
+    KojiInstanceConfig,
+    KojiStagedResponse,
     Response,
     StagedResponse,
     TimePeriod,
@@ -49,6 +71,7 @@ from logdetective.server.emoji import (
     collect_emojis,
     collect_emojis_for_mr,
 )
+from logdetective.server.compressors import RemoteLogCompressor
 
 
 LOG_SOURCE_REQUEST_TIMEOUT = os.environ.get("LOG_SOURCE_REQUEST_TIMEOUT", 60)
@@ -178,6 +201,173 @@ async def analyze_log_staged(
     return await perform_staged_analysis(log_text)
 
 
+@app.get(
+    "/analyze/rpmbuild/koji/{koji_instance}/{task_id}",
+    response_model=KojiStagedResponse,
+)
+async def get_koji_task_analysis(
+    koji_instance: Annotated[str, Path(title="The Koji instance to use")],
+    task_id: Annotated[int, Path(title="The task ID to analyze")],
+    x_koji_token: Annotated[str, Header()] = "",
+):
+    """Provide endpoint for retrieving log file analysis of a Koji task"""
+
+    try:
+        koji_instance_config = SERVER_CONFIG.koji.instances[koji_instance]
+    except KeyError:
+        # This Koji instance is not configured, so we will return a 404.
+        return BasicResponse(status_code=404, content="Unknown Koji instance.")
+
+    # This should always be available in a production environment.
+    # In a testing environment, the tokens list may be empty, in which case
+    # it will just proceed.
+    if koji_instance_config.tokens and x_koji_token not in koji_instance_config.tokens:
+        # (Unauthorized) error.
+        return BasicResponse(x_koji_token, status_code=401)
+
+    # Check if we have a response for this task
+    try:
+        return KojiTaskAnalysis.get_response_by_task_id(task_id)
+
+    except (KojiInvalidTaskID, KojiTaskNotFoundError):
+        # This task ID is malformed, out of range, or not found, so we will
+        # return a 404.
+        return BasicResponse(status_code=404)
+
+    except KojiTaskAnalysisTimeoutError:
+        # Task analysis has timed out, so we assume that the request was lost
+        # and that we need to start another analysis.
+        # There isn't a fully-appropriate error code for this, so we'll use
+        # 503 (Service Unavailable) as our best option.
+        return BasicResponse(
+            status_code=503, content="Task analysis timed out, please retry."
+        )
+
+    except KojiTaskNotAnalyzedError:
+        # Its still running, so we need to return a 202
+        # (Accepted) code to let the client know to keep waiting.
+        return BasicResponse(
+            status_code=202, content=f"Analysis still in progress for task {task_id}"
+        )
+
+
+@app.post(
+    "/analyze/rpmbuild/koji/{koji_instance}/{task_id}",
+    response_model=KojiStagedResponse,
+)
+async def analyze_rpmbuild_koji(
+    koji_instance: Annotated[str, Path(title="The Koji instance to use")],
+    task_id: Annotated[int, Path(title="The task ID to analyze")],
+    x_koji_token: Annotated[str, Header()] = "",
+    x_koji_callback: Annotated[str, Header()] = "",
+    background_tasks: BackgroundTasks = BackgroundTasks(),
+):
+    """Provide endpoint for retrieving log file analysis of a Koji task"""
+
+    try:
+        koji_instance_config = SERVER_CONFIG.koji.instances[koji_instance]
+    except KeyError:
+        # This Koji instance is not configured, so we will return a 404.
+        return BasicResponse(status_code=404, content="Unknown Koji instance.")
+
+    # This should always be available in a production environment.
+    # In a testing environment, the tokens list may be empty, in which case
+    # it will just proceed.
+    if koji_instance_config.tokens and x_koji_token not in koji_instance_config.tokens:
+        # (Unauthorized) error.
+        return BasicResponse(x_koji_token, status_code=401)
+
+    # Check if we already have a response for this task
+    try:
+        response = KojiTaskAnalysis.get_response_by_task_id(task_id)
+
+    except KojiInvalidTaskID:
+        # This task ID is malformed or out of range, so we will return a 400.
+        response = BasicResponse(status_code=404, content="Invalid or unknown task ID.")
+
+    except (KojiTaskNotFoundError, KojiTaskAnalysisTimeoutError):
+        # Task not yet analyzed or it timed out, so we need to start the
+        # analysis in the background and return a 202 (Accepted) error.
+
+        background_tasks.add_task(
+            analyze_koji_task,
+            task_id,
+            koji_instance_config,
+        )
+
+        # If a callback URL is provided, we need to add it to the callbacks
+        # table so that we can notify it when the analysis is complete.
+        if x_koji_callback:
+            koji_instance_config.register_callback(task_id, x_koji_callback)
+
+        response = BasicResponse(
+            status_code=202, content=f"Beginning analysis of task {task_id}"
+        )
+
+    except KojiTaskNotAnalyzedError:
+        # Its still running, so we need to return a 202
+        # (Accepted) error.
+        response = BasicResponse(
+            status_code=202, content=f"Analysis still in progress for task {task_id}"
+        )
+
+    return response
+
+
+async def analyze_koji_task(task_id: int, koji_instance_config: KojiInstanceConfig):
+    """Analyze a koji task and return the response"""
+
+    # Get the log text from the koji task
+    koji_conn = koji_instance_config.get_connection()
+    log_file_name, log_text = await get_failed_log_from_koji_task(
+        koji_conn, task_id, max_size=SERVER_CONFIG.koji.max_artifact_size
+    )
+
+    # We need to handle the metric tracking manually here, because we need
+    # to retrieve the metric ID to associate it with the koji task analysis.
+
+    metrics_id = await add_new_metrics(
+        "analyze_koji_task",
+        log_text,
+        received_at=datetime.datetime.now(datetime.timezone.utc),
+        compressed_log_content=RemoteLogCompressor.zip_text(log_text),
+    )
+
+    # We need to associate the metric ID with the koji task analysis.
+    # This will create the new row without a response, which we will use as
+    # an indicator that the analysis is in progress.
+    KojiTaskAnalysis.create_or_restart(
+        koji_instance=koji_instance_config.xmlrpc_url,
+        task_id=task_id,
+        log_file_name=log_file_name,
+    )
+    response = await perform_staged_analysis(log_text)
+
+    # Now that we have the response, we can update the metrics and mark the
+    # koji task analysis as completed.
+    update_metrics(metrics_id, response)
+    KojiTaskAnalysis.add_response(task_id, metrics_id)
+
+    # Notify any callbacks that the analysis is complete.
+    for callback in koji_instance_config.get_callbacks(task_id):
+        LOG.info("Notifying callback %s of task %d completion", callback, task_id)
+        asyncio.create_task(
+            send_koji_callback(callback, task_id)
+        )
+
+    # Now that it's sent, we can clear the callbacks for this task.
+    koji_instance_config.clear_callbacks(task_id)
+
+    return response
+
+
+async def send_koji_callback(callback: str, task_id: int):
+    """Send a callback to the specified URL with the task ID and log file name."""
+    async with aiohttp.ClientSession() as session:
+        async with session.post(callback, json={"task_id": task_id}):
+            pass
+
+
 @app.get("/queue/print")
 async def queue_print(msg: str):
     """Debug endpoint to test the LLM request queue"""

{logdetective-1.6.0 → logdetective-1.7.0}/logdetective/server/templates/gitlab_full_comment.md.j2

@@ -58,7 +58,9 @@ 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>
 
-
+<i>If this Log Detective report contains harmful content, please use the
+[Gitlab reporting feature for harmful content](https://docs.gitlab.com/user/report_abuse/)
+and contact the [Log Detective developers](https://github.com/fedora-copr/logdetective/issues).</i>
 
 [log-detective]: https://log-detective.com/
 [contact]: https://github.com/fedora-copr

{logdetective-1.6.0 → logdetective-1.7.0}/logdetective/server/templates/gitlab_short_comment.md.j2

@@ -47,7 +47,9 @@ 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>
 
-
+<i>If this Log Detective report contains harmful content, please use the
+[Gitlab reporting feature for harmful content](https://docs.gitlab.com/user/report_abuse/)
+and contact the [Log Detective developers](https://github.com/fedora-copr/logdetective/issues).</i>
 
 [log-detective]: https://log-detective.com/
 [contact]: https://github.com/fedora-copr

{logdetective-1.6.0 → logdetective-1.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "logdetective"
-version = "1.6.0"
+version = "1.7.0"
 description = "Log using LLM AI to search for build/test failures and provide ideas for fixing these."
 authors = ["Jiri Podivin <jpodivin@gmail.com>"]
 license = "Apache-2.0"