logdetective 1.5.0__py3-none-any.whl → 1.7.0__py3-none-any.whl

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/server/llm.py

@@ -16,7 +16,13 @@ from logdetective.utils import (
     compute_certainty,
     prompt_to_messages,
 )
-from logdetective.server.config import LOG, SERVER_CONFIG, PROMPT_CONFIG, CLIENT
+from logdetective.server.config import (
+    LOG,
+    SERVER_CONFIG,
+    PROMPT_CONFIG,
+    CLIENT,
+    SKIP_SNIPPETS_CONFIG,
+)
 from logdetective.server.models import (
     AnalyzedSnippet,
     InferenceConfig,
@@ -42,7 +48,10 @@ def format_analyzed_snippets(snippets: list[AnalyzedSnippet]) -> str:
 def mine_logs(log: str) -> List[Tuple[int, str]]:
     """Extract snippets from log text"""
     extractor = DrainExtractor(
-        verbose=True, context=True, max_clusters=SERVER_CONFIG.extractor.max_clusters
+        verbose=True,
+        context=True,
+        max_clusters=SERVER_CONFIG.extractor.max_clusters,
+        skip_snippets=SKIP_SNIPPETS_CONFIG,
     )
 
     LOG.info("Getting summary")

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/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/server/plot.py

@@ -2,12 +2,10 @@ import datetime
 from typing import Optional, Union, Dict
 
 import numpy
-import matplotlib
-import matplotlib.figure
-import matplotlib.pyplot
+from numpy.typing import ArrayLike
+from matplotlib import dates, colormaps, axes, pyplot, figure
 
-from matplotlib.pyplot import cm
-from logdetective.server import models
+from logdetective.server.models import TimePeriod
 from logdetective.server.database.models import (
     AnalyzeRequestMetrics,
     EndpointType,
@@ -18,25 +16,25 @@ from logdetective.server.database.models import (
 class Definition:
     """Define plot details, given a time period."""
 
-    def __init__(self, time_period: models.TimePeriod):
+    def __init__(self, time_period: TimePeriod):
         self.time_period = time_period
         self.days_diff = time_period.get_time_period().days
         if self.time_period.hours:
             self._freq = "H"
             self._time_format = "%Y-%m-%d %H"
-            self._locator = matplotlib.dates.HourLocator(interval=2)
+            self._locator = dates.HourLocator(interval=2)
             self._time_unit = "hour"
             self._time_delta = datetime.timedelta(hours=1)
         elif self.time_period.days:
             self._freq = "D"
             self._time_format = "%Y-%m-%d"
-            self._locator = matplotlib.dates.DayLocator(interval=1)
+            self._locator = dates.DayLocator(interval=1)
             self._time_unit = "day"
             self._time_delta = datetime.timedelta(days=1)
         elif self.time_period.weeks:
             self._freq = "W"
             self._time_format = "%Y-%m-%d"
-            self._locator = matplotlib.dates.WeekdayLocator(interval=1)
+            self._locator = dates.WeekdayLocator(interval=1)
             self._time_unit = "week"
             self._time_delta = datetime.timedelta(weeks=1)
 
@@ -120,10 +118,10 @@ def create_time_series_arrays(
 
 
 def _add_bar_chart(
-    ax: matplotlib.figure.Axes,
+    ax: axes.Axes,
     plot_def: Definition,
-    timestamps: numpy.array,
-    values: numpy.array,
+    timestamps: ArrayLike,
+    values: ArrayLike,
     label: str,
 ) -> None:
     """Add a blue bar chart"""
@@ -142,18 +140,18 @@ def _add_bar_chart(
     ax.set_ylabel(label, color="blue")
     ax.tick_params(axis="y", labelcolor="blue")
 
-    ax.xaxis.set_major_formatter(matplotlib.dates.DateFormatter(plot_def.time_format))
+    ax.xaxis.set_major_formatter(dates.DateFormatter(plot_def.time_format))
     ax.xaxis.set_major_locator(plot_def.locator)
 
-    matplotlib.pyplot.xticks(rotation=45)
+    pyplot.xticks(rotation=45)
 
     ax.grid(True, alpha=0.3)
 
 
 def _add_line_chart(  # pylint: disable=too-many-arguments disable=too-many-positional-arguments
-    ax: matplotlib.figure.Axes,
-    timestamps: numpy.array,
-    values: numpy.array,
+    ax: axes.Axes,
+    timestamps: ArrayLike,
+    values: ArrayLike,
     label: str,
     color: str = "red",
     set_label: bool = True,
@@ -166,10 +164,10 @@ def _add_line_chart(  # pylint: disable=too-many-arguments disable=too-many-posi
 
 
 def requests_per_time(
-    period_of_time: models.TimePeriod,
+    period_of_time: TimePeriod,
     endpoint: EndpointType = EndpointType.ANALYZE,
     end_time: Optional[datetime.datetime] = None,
-) -> matplotlib.figure.Figure:
+) -> figure.Figure:
     """
     Generate a visualization of request counts over a specified time period.
 
@@ -200,13 +198,13 @@ def requests_per_time(
         requests_counts, plot_def, start_time, end_time
     )
 
-    fig, ax1 = matplotlib.pyplot.subplots(figsize=(12, 6))
+    fig, ax1 = pyplot.subplots(figsize=(12, 6))
     _add_bar_chart(ax1, plot_def, timestamps, counts, "Requests")
 
     ax2 = ax1.twinx()
     _add_line_chart(ax2, timestamps, numpy.cumsum(counts), "Cumulative Requests")
 
-    matplotlib.pyplot.title(
+    pyplot.title(
         f"Requests received for API {endpoint} ({start_time.strftime(plot_def.time_format)} "
         f"to {end_time.strftime(plot_def.time_format)})"
     )
@@ -215,16 +213,16 @@ def requests_per_time(
     lines2, labels2 = ax2.get_legend_handles_labels()
     ax1.legend(lines1 + lines2, labels1 + labels2, loc="center")
 
-    matplotlib.pyplot.tight_layout()
+    pyplot.tight_layout()
 
     return fig
 
 
 def average_time_per_responses(  # pylint: disable=too-many-locals
-    period_of_time: models.TimePeriod,
+    period_of_time: TimePeriod,
     endpoint: EndpointType = EndpointType.ANALYZE,
     end_time: Optional[datetime.datetime] = None,
-) -> matplotlib.figure.Figure:
+) -> figure.Figure:
     """
     Generate a visualization of average response time and length over a specified time period.
 
@@ -259,7 +257,7 @@ def average_time_per_responses(  # pylint: disable=too-many-locals
         float,
     )
 
-    fig, ax1 = matplotlib.pyplot.subplots(figsize=(12, 6))
+    fig, ax1 = pyplot.subplots(figsize=(12, 6))
     _add_bar_chart(
         ax1, plot_def, timestamps, average_time, "average response time (seconds)"
     )
@@ -280,7 +278,7 @@ def average_time_per_responses(  # pylint: disable=too-many-locals
     ax2 = ax1.twinx()
     _add_line_chart(ax2, timestamps, average_length, "average response length (chars)")
 
-    matplotlib.pyplot.title(
+    pyplot.title(
         f"average response time for API {endpoint} ({start_time.strftime(plot_def.time_format)} "
         f"to {end_time.strftime(plot_def.time_format)})"
     )
@@ -289,7 +287,7 @@ def average_time_per_responses(  # pylint: disable=too-many-locals
     lines2, labels2 = ax2.get_legend_handles_labels()
     ax1.legend(lines1 + lines2, labels1 + labels2, loc="center")
 
-    matplotlib.pyplot.tight_layout()
+    pyplot.tight_layout()
 
     return fig
 
@@ -322,7 +320,7 @@ def _collect_emoji_data(
 
 
 def _plot_emoji_data(  # pylint: disable=too-many-locals
-    ax: matplotlib.figure.Axes,
+    ax: axes.Axes,
     reactions_values_dict: Dict[str, Dict[datetime.datetime, int]],
     plot_def: Definition,
     start_time: datetime.datetime,
@@ -340,7 +338,10 @@ def _plot_emoji_data(  # pylint: disable=too-many-locals
         )
         all_counts.extend(counts)
 
-    colors = [cm.viridis(i) for i in numpy.linspace(0, 1, len(reactions_values_dict))]  # pylint: disable=no-member
+    colors = [
+        colormaps["viridis"](i)
+        for i in numpy.linspace(0, 1, len(reactions_values_dict))
+    ]
 
     first_emoji = True
     for i, (emoji, dict_counts) in enumerate(reactions_values_dict.items()):
@@ -369,9 +370,9 @@ def _plot_emoji_data(  # pylint: disable=too-many-locals
 
 
 def emojis_per_time(
-    period_of_time: models.TimePeriod,
+    period_of_time: TimePeriod,
     end_time: Optional[datetime.datetime] = None,
-) -> matplotlib.figure.Figure:
+) -> figure.Figure:
     """
     Generate a visualization of overall emoji feedback
     over a specified time period.
@@ -396,13 +397,13 @@ def emojis_per_time(
     start_time = period_of_time.get_period_start_time(end_time)
     reactions_values_dict = _collect_emoji_data(start_time, plot_def)
 
-    fig, ax = matplotlib.pyplot.subplots(figsize=(12, 6))
+    fig, ax = pyplot.subplots(figsize=(12, 6))
 
     emoji_lines, emoji_labels = _plot_emoji_data(
         ax, reactions_values_dict, plot_def, start_time, end_time
     )
 
-    matplotlib.pyplot.title(
+    pyplot.title(
         f"Emoji feedback ({start_time.strftime(plot_def.time_format)} "
         f"to {end_time.strftime(plot_def.time_format)})"
     )
@@ -419,11 +420,11 @@ def emojis_per_time(
     ax.set_ylabel("Count")
 
     # Format x-axis
-    ax.xaxis.set_major_formatter(matplotlib.dates.DateFormatter(plot_def.time_format))
+    ax.xaxis.set_major_formatter(dates.DateFormatter(plot_def.time_format))
     ax.xaxis.set_major_locator(plot_def.locator)
     ax.tick_params(axis="x", labelrotation=45)
     ax.grid(True, alpha=0.3)
 
-    matplotlib.pyplot.tight_layout()
+    pyplot.tight_layout()
 
     return fig