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

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/extractors.py

@@ -5,7 +5,8 @@ from typing import Tuple
 import drain3
 from drain3.template_miner_config import TemplateMinerConfig
 
-from logdetective.utils import get_chunks
+from logdetective.utils import get_chunks, filter_snippet_patterns
+from logdetective.models import SkipSnippets
 
 LOG = logging.getLogger("logdetective")
 
@@ -13,7 +14,13 @@ LOG = logging.getLogger("logdetective")
 class DrainExtractor:
     """A class that extracts information from logs using a template miner algorithm."""
 
-    def __init__(self, verbose: bool = False, context: bool = False, max_clusters=8):
+    def __init__(
+        self,
+        verbose: bool = False,
+        context: bool = False,
+        max_clusters=8,
+        skip_snippets: SkipSnippets = SkipSnippets({}),
+    ):
         config = TemplateMinerConfig()
         config.load(f"{os.path.dirname(__file__)}/drain3.ini")
         config.profiling_enabled = verbose
@@ -21,22 +28,28 @@ class DrainExtractor:
         self.miner = drain3.TemplateMiner(config=config)
         self.verbose = verbose
         self.context = context
+        self.skip_snippets = skip_snippets
 
     def __call__(self, log: str) -> list[Tuple[int, str]]:
         out = []
+        # Create chunks
+        chunks = list(get_chunks(log))
+        # Keep only chunks that don't match any of the excluded patterns
+        chunks = [
+            (_, chunk)
+            for _, chunk in chunks
+            if not filter_snippet_patterns(chunk, self.skip_snippets)
+        ]
         # First pass create clusters
-        for _, chunk in get_chunks(log):
+        for _, chunk in chunks:
             processed_chunk = self.miner.add_log_message(chunk)
             LOG.debug(processed_chunk)
-        # Sort found clusters by size, descending order
-        sorted_clusters = sorted(
-            self.miner.drain.clusters, key=lambda it: it.size, reverse=True
-        )
+        clusters = list(self.miner.drain.clusters)
         # Second pass, only matching lines with clusters,
         # to recover original text
-        for chunk_start, chunk in get_chunks(log):
+        for chunk_start, chunk in chunks:
             cluster = self.miner.match(chunk, "always")
-            if cluster in sorted_clusters:
+            if cluster in clusters:
                 out.append((chunk_start, chunk))
-                sorted_clusters.remove(cluster)
+                clusters.remove(cluster)
         return out

logdetective/logdetective.py

@@ -14,6 +14,7 @@ from logdetective.utils import (
     format_snippets,
     compute_certainty,
     load_prompts,
+    load_skip_snippet_patterns,
 )
 from logdetective.extractors import DrainExtractor
 
@@ -41,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(
@@ -82,6 +83,12 @@ def setup_args():
         default=DEFAULT_TEMPERATURE,
         help="Temperature for inference.",
     )
+    parser.add_argument(
+        "--skip_snippets",
+        type=str,
+        default=f"{os.path.dirname(__file__)}/skip_snippets.yml",
+        help="Path to patterns for skipping snippets.",
+    )
     return parser.parse_args()
 
 
@@ -120,9 +127,18 @@ async def run():  # pylint: disable=too-many-statements,too-many-locals
         LOG.error("You likely do not have enough memory to load the AI model")
         sys.exit(3)
 
+    try:
+        skip_snippets = load_skip_snippet_patterns(args.skip_snippets)
+    except OSError as e:
+        LOG.error(e)
+        sys.exit(5)
+
     # Log file summarizer initialization
     extractor = DrainExtractor(
-        args.verbose > 1, context=True, max_clusters=args.n_clusters
+        args.verbose > 1,
+        context=True,
+        max_clusters=args.n_clusters,
+        skip_snippets=skip_snippets,
     )
 
     LOG.info("Getting summary")

logdetective/models.py

@@ -1,5 +1,6 @@
+import re
 from typing import Optional
-from pydantic import BaseModel
+from pydantic import BaseModel, model_validator
 
 from logdetective.constants import (
     PROMPT_TEMPLATE,
@@ -40,3 +41,33 @@ class PromptConfig(BaseModel):
         self.staged_system_prompt = data.get(
             "staged_system_prompt", DEFAULT_SYSTEM_PROMPT
         )
+
+
+class SkipSnippets(BaseModel):
+    """Regular expressions defining snippets we should not analyze"""
+
+    snippet_patterns: dict[str, re.Pattern] = {}
+
+    def __init__(self, data: Optional[dict] = None):
+        super().__init__(data=data)
+        if data is None:
+            return
+        self.snippet_patterns = {
+            key: re.compile(pattern) for key, pattern in data.items()
+        }
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_patterns(cls, data: dict):
+        """Check if all supplied patterns are valid regular expressions.
+        Techically replicating what is done in __init__ but with nicer error message."""
+        patterns = data["data"]
+        for key, pattern in patterns.items():
+            try:
+                re.compile(pattern=pattern)
+            except (TypeError, re.error) as ex:
+                raise ValueError(
+                    f"Invalid pattern `{pattern}` with name `{key}` supplied for skipping in logs."
+                ) from ex
+
+        return data

logdetective/remote_log.py

@@ -53,7 +53,7 @@ class RemoteLog:
             LOG.debug("process url %s", self.url)
             try:
                 response = await self._http_session.get(self.url, raise_for_status=True)
-            except aiohttp.ClientResponseError as ex:
+            except (aiohttp.ClientResponseError, aiohttp.ClientConnectorError) as ex:
                 raise RuntimeError(f"We couldn't obtain the logs: {ex}") from ex
             return await response.text()
         LOG.error("Invalid URL received ")

logdetective/server/config.py

@@ -3,8 +3,9 @@ import logging
 import yaml
 from openai import AsyncOpenAI
 
-from logdetective.utils import load_prompts
+from logdetective.utils import load_prompts, load_skip_snippet_patterns
 from logdetective.server.models import Config, InferenceConfig
+import logdetective
 
 
 def load_server_config(path: str | None) -> Config:
@@ -60,9 +61,16 @@ def get_openai_api_client(ineference_config: InferenceConfig):
 
 SERVER_CONFIG_PATH = os.environ.get("LOGDETECTIVE_SERVER_CONF", None)
 SERVER_PROMPT_PATH = os.environ.get("LOGDETECTIVE_PROMPTS", None)
+# The default location for skip patterns is in the same directory
+# as logdetective __init__.py file.
+SERVER_SKIP_PATTERNS_PATH = os.environ.get(
+    "LOGDETECIVE_SKIP_PATTERNS",
+    f"{os.path.dirname(logdetective.__file__)}/skip_snippets.yml",
+)
 
 SERVER_CONFIG = load_server_config(SERVER_CONFIG_PATH)
 PROMPT_CONFIG = load_prompts(SERVER_PROMPT_PATH)
+SKIP_SNIPPETS_CONFIG = load_skip_snippet_patterns(SERVER_SKIP_PATTERNS_PATH)
 
 LOG = get_log(SERVER_CONFIG)
 

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/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/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/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/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/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/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/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,