logdetective 2.11.0__py3-none-any.whl → 2.13.0__py3-none-any.whl

logdetective/server/config.py

@@ -15,7 +15,7 @@ def load_server_config(path: str | None) -> Config:
     if path is not None:
         try:
             with open(path, "r") as config_file:
-                return Config(yaml.safe_load(config_file))
+                return Config.model_validate(yaml.safe_load(config_file))
         except FileNotFoundError:
             # This is not an error, we will fall back to default
             print("Unable to find server config file, using default then.")

logdetective/server/database/base.py

@@ -22,7 +22,7 @@ sqlalchemy_echo = getenv("SQLALCHEMY_ECHO", "False").lower() in (
     "y",
     "1",
 )
-engine = create_async_engine(get_pg_url(), echo=sqlalchemy_echo)
+engine = create_async_engine(get_pg_url(), echo=sqlalchemy_echo, pool_pre_ping=True)
 SessionFactory = async_sessionmaker(autoflush=True, bind=engine)  # pylint: disable=invalid-name
 
 

logdetective/server/gitlab.py

@@ -4,6 +4,7 @@ import zipfile
 from pathlib import Path, PurePath
 from tempfile import TemporaryFile
 
+from aiolimiter import AsyncLimiter
 from fastapi import HTTPException
 
 import gitlab
@@ -13,6 +14,7 @@ import jinja2
 import aiohttp
 import backoff
 
+from logdetective.extractors import Extractor
 from logdetective.server.config import SERVER_CONFIG, LOG
 from logdetective.server.exceptions import (
     LogsTooLargeError,
@@ -41,15 +43,20 @@ FAILURE_LOG_REGEX = re.compile(r"(\w*\.log)")
 
 async def process_gitlab_job_event(
     gitlab_cfg: GitLabInstanceConfig,
+    gitlab_connection: gitlab.Gitlab,
+    http_session: aiohttp.ClientSession,
     forge: Forge,
     job_hook: JobHook,
-):  # pylint: disable=too-many-locals
+    async_request_limiter: AsyncLimiter,
+    extractors: list[Extractor],
+):  # pylint: disable=too-many-locals disable=too-many-arguments disable=too-many-positional-arguments
     """Handle a received job_event webhook from GitLab"""
     LOG.debug("Received webhook message from %s:\n%s", forge.value, job_hook)
 
     # Look up the project this job belongs to
-    gitlab_conn = gitlab_cfg.get_connection()
-    project = await asyncio.to_thread(gitlab_conn.projects.get, job_hook.project_id)
+    project = await asyncio.to_thread(
+        gitlab_connection.projects.get, job_hook.project_id
+    )
     LOG.info("Processing failed job for %s", project.name)
 
     # Retrieve data about the job from the GitLab API
@@ -94,7 +101,7 @@ async def process_gitlab_job_event(
     # Retrieve the build logs from the merge request artifacts and preprocess them
     try:
         log_url, preprocessed_log = await retrieve_and_preprocess_koji_logs(
-            gitlab_cfg, job
+            gitlab_cfg, job, http_session
         )
     except (LogsTooLargeError, LogDetectiveConnectionError) as ex:
         LOG.error("Could not retrieve logs due to %s", ex)
@@ -105,10 +112,14 @@ async def process_gitlab_job_event(
     metrics_id = await add_new_metrics(
         api_name=EndpointType.ANALYZE_GITLAB_JOB,
         url=log_url,
-        http_session=gitlab_cfg.get_http_session(),
+        http_session=http_session,
         compressed_log_content=RemoteLogCompressor.zip_text(log_text),
     )
-    staged_response = await perform_staged_analysis(log_text=log_text)
+    staged_response = await perform_staged_analysis(
+        log_text=log_text,
+        async_request_limiter=async_request_limiter,
+        extractors=extractors,
+    )
     await update_metrics(metrics_id, staged_response)
     preprocessed_log.close()
 
@@ -162,6 +173,7 @@ def is_eligible_package(project_name: str):
 async def retrieve_and_preprocess_koji_logs(
     gitlab_cfg: GitLabInstanceConfig,
     job: gitlab.v4.objects.ProjectJob,
+    http_session: aiohttp.ClientSession,
 ):  # pylint: disable=too-many-branches,too-many-locals
     """Download logs from the merge request artifacts
 
@@ -173,7 +185,7 @@ async def retrieve_and_preprocess_koji_logs(
     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(gitlab_cfg, job):
+    if not await check_artifacts_file_size(gitlab_cfg, job, http_session):
         raise LogsTooLargeError(
             f"Oversized logs for job {job.id} in project {job.project_id}"
         )
@@ -274,6 +286,7 @@ async def retrieve_and_preprocess_koji_logs(
 async def check_artifacts_file_size(
     gitlab_cfg: GitLabInstanceConfig,
     job: gitlab.v4.objects.ProjectJob,
+    http_session: aiohttp.ClientSession,
 ):
     """Method to determine if the artifacts are too large to process"""
     # First, make sure that the artifacts are of a reasonable size. The
@@ -285,7 +298,7 @@ async def check_artifacts_file_size(
     )
     LOG.debug("checking artifact URL %s%s", gitlab_cfg.url, artifacts_path)
     try:
-        head_response = await gitlab_cfg.get_http_session().head(
+        head_response = await http_session.head(
             artifacts_path,
             allow_redirects=True,
             raise_for_status=True,

logdetective/server/llm.py

@@ -9,9 +9,11 @@ from fastapi import HTTPException
 from pydantic import ValidationError
 
 import aiohttp
+from aiolimiter import AsyncLimiter
 from openai import AsyncStream
 from openai.types.chat import ChatCompletionChunk
 
+from logdetective.extractors import Extractor
 from logdetective.utils import (
     compute_certainty,
     prompt_to_messages,
@@ -41,7 +43,6 @@ from logdetective.server.utils import (
     construct_final_prompt,
 )
 
-
 LLM_CPP_SERVER_TIMEOUT = os.environ.get("LLAMA_CPP_SERVER_TIMEOUT", 600)
 
 
@@ -57,6 +58,7 @@ LLM_CPP_SERVER_TIMEOUT = os.environ.get("LLAMA_CPP_SERVER_TIMEOUT", 600)
 async def call_llm(
     messages: List[Dict[str, str]],
     inference_cfg: InferenceConfig,
+    async_request_limiter: AsyncLimiter,
     stream: bool = False,
     structured_output: dict | None = None,
 ) -> Explanation:
@@ -87,7 +89,7 @@ async def call_llm(
         }
         kwargs["response_format"] = response_format
 
-    async with inference_cfg.get_limiter():
+    async with async_request_limiter:
         response = await CLIENT.chat.completions.create(
             messages=messages,
             max_tokens=inference_cfg.max_tokens,
@@ -126,6 +128,7 @@ async def call_llm(
 async def call_llm_stream(
     messages: List[Dict[str, str]],
     inference_cfg: InferenceConfig,
+    async_request_limiter: AsyncLimiter,
     stream: bool = False,
 ) -> AsyncStream[ChatCompletionChunk]:
     """Submit prompt to LLM and recieve stream of tokens as a result.
@@ -136,7 +139,7 @@ async def call_llm_stream(
 
     LOG.info("Submitting to /v1/chat/completions endpoint")
 
-    async with inference_cfg.get_limiter():
+    async with async_request_limiter:
         response = await CLIENT.chat.completions.create(
             messages=messages,
             max_tokens=inference_cfg.max_tokens,
@@ -150,7 +153,9 @@ async def call_llm_stream(
 
 
 async def analyze_snippets(
-    log_summary: List[Tuple[int, str]], structured_output: dict | None = None
+    log_summary: List[Tuple[int, str]],
+    async_request_limiter: AsyncLimiter,
+    structured_output: dict | None = None,
 ) -> List[SnippetAnalysis | RatedSnippetAnalysis]:
     """Submit log file snippets to the LLM and gather results"""
     # Process snippets asynchronously
@@ -162,6 +167,7 @@ async def analyze_snippets(
                 SERVER_CONFIG.inference.system_role,
                 SERVER_CONFIG.inference.user_role,
             ),
+            async_request_limiter=async_request_limiter,
             inference_cfg=SERVER_CONFIG.snippet_inference,
             structured_output=structured_output,
         )
@@ -184,9 +190,13 @@ async def analyze_snippets(
     return analyzed_snippets
 
 
-async def perfrom_analysis(log_text: str) -> Response:
+async def perform_analysis(
+    log_text: str,
+    async_request_limiter: AsyncLimiter,
+    extractors: List[Extractor],
+) -> Response:
     """Sumbit log file snippets in aggregate to LLM and retrieve results"""
-    log_summary = mine_logs(log_text, SERVER_CONFIG.extractor.get_extractors())
+    log_summary = mine_logs(log_text, extractors)
     log_summary = format_snippets(log_summary)
 
     final_prompt = construct_final_prompt(log_summary, PROMPT_CONFIG.prompt_template)
@@ -199,6 +209,7 @@ async def perfrom_analysis(log_text: str) -> Response:
     )
     response = await call_llm(
         messages,
+        async_request_limiter=async_request_limiter,
         inference_cfg=SERVER_CONFIG.inference,
     )
     certainty = 0
@@ -216,9 +227,13 @@ async def perfrom_analysis(log_text: str) -> Response:
     return Response(explanation=response, response_certainty=certainty)
 
 
-async def perform_analyis_stream(log_text: str) -> AsyncStream:
+async def perform_analysis_stream(
+    log_text: str,
+    async_request_limiter: AsyncLimiter,
+    extractors: List[Extractor],
+) -> AsyncStream:
     """Submit log file snippets in aggregate and return a stream of tokens"""
-    log_summary = mine_logs(log_text, SERVER_CONFIG.extractor.get_extractors())
+    log_summary = mine_logs(log_text, extractors)
     log_summary = format_snippets(log_summary)
 
     final_prompt = construct_final_prompt(log_summary, PROMPT_CONFIG.prompt_template)
@@ -232,6 +247,7 @@ async def perform_analyis_stream(log_text: str) -> AsyncStream:
 
     stream = call_llm_stream(
         messages,
+        async_request_limiter=async_request_limiter,
         inference_cfg=SERVER_CONFIG.inference,
     )
 
@@ -241,13 +257,18 @@ async def perform_analyis_stream(log_text: str) -> AsyncStream:
     return stream
 
 
-async def perform_staged_analysis(log_text: str) -> StagedResponse:
+async def perform_staged_analysis(
+    log_text: str,
+    async_request_limiter: AsyncLimiter,
+    extractors: List[Extractor],
+) -> StagedResponse:
     """Submit the log file snippets to the LLM and retrieve their results"""
-    log_summary = mine_logs(log_text, SERVER_CONFIG.extractor.get_extractors())
+    log_summary = mine_logs(log_text, extractors)
     start = time.time()
     if SERVER_CONFIG.general.top_k_snippets:
         rated_snippets = await analyze_snippets(
             log_summary=log_summary,
+            async_request_limiter=async_request_limiter,
             structured_output=RatedSnippetAnalysis.model_json_schema(),
         )
 
@@ -266,7 +287,9 @@ async def perform_staged_analysis(log_text: str) -> StagedResponse:
             len(rated_snippets),
         )
     else:
-        processed_snippets = await analyze_snippets(log_summary=log_summary)
+        processed_snippets = await analyze_snippets(
+            log_summary=log_summary, async_request_limiter=async_request_limiter
+        )
 
         # Extract original text and line number from `log_summary`
         processed_snippets = [
@@ -276,7 +299,9 @@ async def perform_staged_analysis(log_text: str) -> StagedResponse:
     delta = time.time() - start
     LOG.info("Snippet analysis performed in %f s", delta)
     log_summary = format_analyzed_snippets(processed_snippets)
-    final_prompt = construct_final_prompt(log_summary, PROMPT_CONFIG.prompt_template_staged)
+    final_prompt = construct_final_prompt(
+        log_summary, PROMPT_CONFIG.prompt_template_staged
+    )
 
     messages = prompt_to_messages(
         final_prompt,
@@ -286,6 +311,7 @@ async def perform_staged_analysis(log_text: str) -> StagedResponse:
     )
     final_analysis = await call_llm(
         messages,
+        async_request_limiter=async_request_limiter,
         inference_cfg=SERVER_CONFIG.inference,
     )
 

logdetective/server/models.py

@@ -1,8 +1,6 @@
-import asyncio
-from collections import defaultdict
 import datetime
 from logging import BASIC_FORMAT
-from typing import List, Dict, Optional
+from typing import List, Dict, Optional, Any
 from pydantic import (
     BaseModel,
     Field,
@@ -10,14 +8,8 @@ from pydantic import (
     field_validator,
     NonNegativeFloat,
     HttpUrl,
-    PrivateAttr,
 )
 
-import aiohttp
-
-from aiolimiter import AsyncLimiter
-from gitlab import Gitlab
-import koji
 
 from logdetective.constants import (
     DEFAULT_TEMPERATURE,
@@ -26,8 +18,6 @@ from logdetective.constants import (
     SYSTEM_ROLE_DEFAULT,
     USER_ROLE_DEFAULT,
 )
-
-from logdetective.extractors import Extractor, DrainExtractor, CSGrepExtractor
 from logdetective.utils import check_csgrep
 
 
@@ -177,40 +167,14 @@ class InferenceConfig(BaseModel):  # pylint: disable=too-many-instance-attribute
     # OpenAI client library requires a string to be specified for API token
     # even if it is not checked on the server side
     api_token: str = "None"
-    model: str = ""
+    model: str = "default-model"
     temperature: NonNegativeFloat = DEFAULT_TEMPERATURE
     max_queue_size: int = LLM_DEFAULT_MAX_QUEUE_SIZE
     http_timeout: float = 5.0
     user_role: str = USER_ROLE_DEFAULT
     system_role: str = SYSTEM_ROLE_DEFAULT
     llm_api_timeout: float = 15.0
-    _limiter: AsyncLimiter = PrivateAttr(
-        default_factory=lambda: AsyncLimiter(LLM_DEFAULT_REQUESTS_PER_MINUTE))
-
-    def __init__(self, data: Optional[dict] = None):
-        super().__init__()
-        if data is None:
-            return
-
-        self.max_tokens = data.get("max_tokens", -1)
-        self.log_probs = data.get("log_probs", True)
-        self.url = data.get("url", "")
-        self.http_timeout = data.get("http_timeout", 5.0)
-        self.api_token = data.get("api_token", "None")
-        self.model = data.get("model", "default-model")
-        self.temperature = data.get("temperature", DEFAULT_TEMPERATURE)
-        self.max_queue_size = data.get("max_queue_size", LLM_DEFAULT_MAX_QUEUE_SIZE)
-        self.user_role = data.get("user_role", USER_ROLE_DEFAULT)
-        self.system_role = data.get("system_role", SYSTEM_ROLE_DEFAULT)
-        self._requests_per_minute = data.get(
-            "requests_per_minute", LLM_DEFAULT_REQUESTS_PER_MINUTE
-        )
-        self.llm_api_timeout = data.get("llm_api_timeout", 15.0)
-        self._limiter = AsyncLimiter(self._requests_per_minute)
-
-    def get_limiter(self):
-        """Return the limiter object so it can be used as a context manager"""
-        return self._limiter
+    requests_per_minute: int = LLM_DEFAULT_REQUESTS_PER_MINUTE
 
 
 class ExtractorConfig(BaseModel):
@@ -221,64 +185,25 @@ class ExtractorConfig(BaseModel):
     max_snippet_len: int = 2000
     csgrep: bool = False
 
-    _extractors: List[Extractor] = PrivateAttr(default_factory=list)
-
-    def _setup_extractors(self):
-        """Initialize extractors with common settings."""
-        self._extractors = [
-            DrainExtractor(
-                verbose=self.verbose,
-                max_snippet_len=self.max_snippet_len,
-                max_clusters=self.max_clusters,
-            )
-        ]
-
-        if self.csgrep:
-            self._extractors.append(
-                CSGrepExtractor(
-                    verbose=self.verbose,
-                    max_snippet_len=self.max_snippet_len,
-                )
-            )
-
-    def __init__(self, data: Optional[dict] = None):
-        super().__init__(data=data)
-
-        if data is None:
-            self._setup_extractors()
-            return
-
-        self.max_clusters = data.get("max_clusters", 8)
-        self.verbose = data.get("verbose", False)
-        self.max_snippet_len = data.get("max_snippet_len", 2000)
-        self.csgrep = data.get("csgrep", False)
-
-        self._setup_extractors()
-
-    def get_extractors(self) -> List[Extractor]:
-        """Return list of initialized extractors, each will be applied in turn
-        on original log text to retrieve snippets."""
-        return self._extractors
-
-    @field_validator("csgrep", mode="after")
+    @field_validator("csgrep", mode="before")
     @classmethod
-    def validate_csgrep(cls, value: bool) -> bool:
-        """Verify that csgrep is available if requested."""
-        if not check_csgrep():
+    def verify_csgrep(cls, v: bool):
+        """Verify presence of csgrep binary if csgrep extractor is requested."""
+        if v and not check_csgrep():
             raise ValueError(
                 "Requested csgrep extractor but `csgrep` binary is not in the PATH"
             )
-        return value
+        return v
 
 
 class GitLabInstanceConfig(BaseModel):  # pylint: disable=too-many-instance-attributes
     """Model for GitLab configuration of logdetective server."""
 
-    name: str = None
-    url: str = None
+    name: str
+    url: str = "https://gitlab.com"
     # Path to API of the gitlab instance, assuming `url` as prefix.
-    api_path: str = None
-    api_token: str = None
+    api_path: str = "/api/v4"
+    api_token: Optional[str] = None
 
     # This is a list to support key rotation.
     # When the key is being changed, we will add the new key as a new entry in
@@ -289,69 +214,17 @@ class GitLabInstanceConfig(BaseModel):  # pylint: disable=too-many-instance-attr
     webhook_secrets: Optional[List[str]] = None
 
     timeout: float = 5.0
-    _conn: Gitlab | None = PrivateAttr(default=None)
-    _http_session: aiohttp.ClientSession | None = PrivateAttr(default=None)
 
     # Maximum size of artifacts.zip in MiB. (default: 300 MiB)
     max_artifact_size: int = 300 * 1024 * 1024
 
-    def __init__(self, name: str, data: Optional[dict] = None):
-        super().__init__()
-        if data is None:
-            return
-
-        self.name = name
-        self.url = data.get("url", "https://gitlab.com")
-        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", 300)) * 1024 * 1024
-
-        self.timeout = data.get("timeout", 5.0)
-        self._conn = Gitlab(
-            url=self.url,
-            private_token=self.api_token,
-            timeout=self.timeout,
-        )
-
-    def get_connection(self):
-        """Get the Gitlab connection object"""
-        return self._conn
-
-    def get_http_session(self):
-        """Return the internal HTTP session so it can be used to contect the
-        Gitlab server. May be used as a context manager."""
-
-        # Create the session on the first attempt. We need to do this "lazily"
-        # because it needs to happen once the event loop is running, even
-        # though the initialization itself is synchronous.
-        if not self._http_session:
-            self._http_session = aiohttp.ClientSession(
-                base_url=self.url,
-                headers={"Authorization": f"Bearer {self.api_token}"},
-                timeout=aiohttp.ClientTimeout(
-                    total=self.timeout,
-                    connect=3.07,
-                ),
-            )
-
-        return self._http_session
-
-    def __del__(self):
-        # Close connection when this object is destroyed
-        if self._http_session:
-            try:
-                loop = asyncio.get_running_loop()
-                loop.create_task(self._http_session.close())
-            except RuntimeError:
-                # No loop running, so create one to close the session
-                loop = asyncio.new_event_loop()
-                loop.run_until_complete(self._http_session.close())
-                loop.close()
-            except Exception:  # pylint: disable=broad-exception-caught
-                # We should only get here if we're shutting down, so we don't
-                # really care if the close() completes cleanly.
-                pass
+    @field_validator("max_artifact_size", mode="before")
+    @classmethod
+    def megabytes_to_bytes(cls, v: Any):
+        """Convert max_artifact_size from megabytes to bytes."""
+        if isinstance(v, int):
+            return v * 1024 * 1024
+        return 300 * 1024 * 1024
 
 
 class GitLabConfig(BaseModel):
@@ -359,63 +232,28 @@ class GitLabConfig(BaseModel):
 
     instances: Dict[str, GitLabInstanceConfig] = {}
 
-    def __init__(self, data: Optional[dict] = None):
-        super().__init__()
-        if data is None:
-            return
+    @model_validator(mode="before")
+    @classmethod
+    def set_gitlab_instance_configs(cls, data: Any):
+        """Initialize configuration for each GitLab instance"""
+        if not isinstance(data, dict):
+            return data
 
+        instances = {}
         for instance_name, instance_data in data.items():
-            instance = GitLabInstanceConfig(instance_name, instance_data)
-            self.instances[instance.url] = instance
+            instance = GitLabInstanceConfig(name=instance_name, **instance_data)
+            instances[instance.url] = instance
+
+        return {"instances": instances}
 
 
 class KojiInstanceConfig(BaseModel):
     """Model for Koji configuration of logdetective server."""
 
     name: str = ""
-    xmlrpc_url: str = ""
+    xmlrpc_url: str = "https://koji.fedoraproject.org/kojihub"
     tokens: List[str] = []
 
-    _conn: Optional[koji.ClientSession] = PrivateAttr(default=None)
-    _callbacks: defaultdict[int, set[str]] = PrivateAttr(default_factory=lambda: 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."""
@@ -424,23 +262,26 @@ class KojiConfig(BaseModel):
     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
+    @field_validator("max_artifact_size", mode="before")
+    @classmethod
+    def megabytes_to_bytes(cls, v: Any):
+        """Convert max_artifact_size from megabytes to bytes."""
+        if isinstance(v, int):
+            return v * 1024 * 1024
+        return 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
-            )
+    @model_validator(mode="before")
+    @classmethod
+    def set_koji_instance_configs(cls, data: Any):
+        """Initialize configuration for each Koji instance."""
+        if isinstance(data, dict):
+            instances = {}
+            for instance_name, instance_data in data.get("instances", {}).items():
+                instances[instance_name] = KojiInstanceConfig(
+                    name=instance_name, **instance_data
+                )
+            data["instances"] = instances
+        return data
 
 
 class LogConfig(BaseModel):
@@ -452,17 +293,6 @@ class LogConfig(BaseModel):
     path: str | None = None
     format: str = BASIC_FORMAT
 
-    def __init__(self, data: Optional[dict] = None):
-        super().__init__()
-        if data is None:
-            return
-
-        self.name = data.get("name", "logdetective")
-        self.level_stream = data.get("level_stream", "INFO").upper()
-        self.level_file = data.get("level_file", "INFO").upper()
-        self.path = data.get("path")
-        self.format = data.get("format", BASIC_FORMAT)
-
 
 class GeneralConfig(BaseModel):
     """General config options for Log Detective"""
@@ -474,50 +304,27 @@ class GeneralConfig(BaseModel):
     collect_emojis_interval: int = 60 * 60  # seconds
     top_k_snippets: int = 0
 
-    def __init__(self, data: Optional[dict] = None):
-        super().__init__()
-        if data is None:
-            return
-
-        self.packages = data.get("packages", [])
-        self.excluded_packages = data.get("excluded_packages", [])
-        self.devmode = data.get("devmode", False)
-        self.sentry_dsn = data.get("sentry_dsn")
-        self.collect_emojis_interval = data.get(
-            "collect_emojis_interval", 60 * 60
-        )  # seconds
-        self.top_k_snippets = data.get("top_k_snippets", 0)
-
 
 class Config(BaseModel):
     """Model for configuration of logdetective server."""
 
-    log: LogConfig = LogConfig()
-    inference: InferenceConfig = InferenceConfig()
-    snippet_inference: InferenceConfig = InferenceConfig()
+    log: LogConfig = Field(default_factory=LogConfig)
+    inference: InferenceConfig = Field(default_factory=InferenceConfig)
+    snippet_inference: InferenceConfig = Field(default_factory=InferenceConfig)
     # TODO(jpodivin): Extend to work with multiple extractor configs
-    extractor: ExtractorConfig = ExtractorConfig()
-    gitlab: GitLabConfig = GitLabConfig()
-    koji: KojiConfig = KojiConfig()
-    general: GeneralConfig = GeneralConfig()
-
-    def __init__(self, data: Optional[dict] = None):
-        super().__init__()
-
-        if data is None:
-            return
-
-        self.log = LogConfig(data.get("log"))
-        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):
-            self.snippet_inference = InferenceConfig(snippet_inference)
-        else:
-            self.snippet_inference = self.inference
+    extractor: ExtractorConfig = Field(default_factory=ExtractorConfig)
+    gitlab: GitLabConfig = Field(default_factory=GitLabConfig)
+    koji: KojiConfig = Field(default_factory=KojiConfig)
+    general: GeneralConfig = Field(default_factory=GeneralConfig)
+
+    @model_validator(mode="before")
+    @classmethod
+    def default_snippet_inference(cls, data: Any):
+        """Use base inference configuration, if specific snippet configuration isn't provided."""
+        if isinstance(data, dict):
+            if "snippet_inference" not in data and "inference" in data:
+                data["snippet_inference"] = data["inference"]
+        return data
 
 
 class TimePeriod(BaseModel):

logdetective/server/server.py

@@ -2,13 +2,17 @@ import os
 import asyncio
 import datetime
 from enum import Enum
+from collections import defaultdict
 from contextlib import asynccontextmanager
 from typing import Annotated
 from io import BytesIO
 
+from aiolimiter import AsyncLimiter
 import matplotlib
 import matplotlib.figure
 import matplotlib.pyplot
+from koji import ClientSession
+from gitlab import Gitlab
 from fastapi import (
     FastAPI,
     HTTPException,
@@ -18,12 +22,12 @@ from fastapi import (
     Path,
     Request,
 )
-
 from fastapi.responses import StreamingResponse
 from fastapi.responses import Response as BasicResponse
 import aiohttp
 import sentry_sdk
 
+from logdetective.extractors import DrainExtractor, CSGrepExtractor, Extractor
 from logdetective.server.exceptions import KojiInvalidTaskID
 
 from logdetective.server.database.models.koji import KojiTaskAnalysis
@@ -42,13 +46,14 @@ from logdetective.server.koji import (
 from logdetective.remote_log import RemoteLog
 from logdetective.server.llm import (
     perform_staged_analysis,
-    perfrom_analysis,
-    perform_analyis_stream,
+    perform_analysis,
+    perform_analysis_stream,
 )
 from logdetective.server.gitlab import process_gitlab_job_event
 from logdetective.server.metric import track_request, add_new_metrics, update_metrics
 from logdetective.server.models import (
     BuildLog,
+    Config,
     EmojiHook,
     JobHook,
     KojiInstanceConfig,
@@ -56,6 +61,7 @@ from logdetective.server.models import (
     Response,
     StagedResponse,
     TimePeriod,
+    ExtractorConfig,
 )
 from logdetective.server import plot as plot_engine
 from logdetective.server.database.models import (
@@ -78,6 +84,89 @@ if sentry_dsn := SERVER_CONFIG.general.sentry_dsn:
     sentry_sdk.init(dsn=str(sentry_dsn), traces_sample_rate=1.0)
 
 
+def initialize_extractors(extractor_config: ExtractorConfig) -> list[Extractor]:
+    """Set up extractors based on provided ExtractorConfig."""
+    extractors: list[Extractor] = [
+        DrainExtractor(
+            verbose=extractor_config.verbose,
+            max_snippet_len=extractor_config.max_snippet_len,
+            max_clusters=extractor_config.max_clusters,
+        )
+    ]
+
+    if extractor_config.csgrep:
+        extractors.append(
+            CSGrepExtractor(
+                verbose=extractor_config.verbose,
+                max_snippet_len=extractor_config.max_snippet_len,
+            )
+        )
+
+    return extractors
+
+
+class ConnectionManager:
+    """
+    Manager for all connections and sesssions.
+    """
+
+    koji_connections: dict[str, ClientSession] = {}
+    gitlab_connections: dict[str, Gitlab] = {}
+    gitlab_http_sessions: dict[str, aiohttp.ClientSession] = {}
+
+    async def initialize(self, service_config: Config):
+        """Initialize all managed objects"""
+
+        for connection, config in service_config.gitlab.instances.items():
+            self.gitlab_connections[connection] = Gitlab(
+                url=config.url,
+                private_token=config.api_token,
+                timeout=config.timeout,
+            )
+            self.gitlab_http_sessions[connection] = aiohttp.ClientSession(
+                base_url=config.url,
+                headers={"Authorization": f"Bearer {config.api_token}"},
+                timeout=aiohttp.ClientTimeout(
+                    total=config.timeout,
+                    connect=3.07,
+                ),
+            )
+        for connection, config in service_config.koji.instances.items():
+            self.koji_connections[connection] = ClientSession(baseurl=config.xmlrpc_url)
+
+    async def close(self):
+        """Close all managed http sessions"""
+        for session in self.gitlab_http_sessions.values():
+
+            await session.close()
+
+
+class KojiCallbackManager:
+    """Manages callbacks used by Koji, with callbacks referenced by task id.
+
+    Multiple callbacks can be assigned to a single task."""
+
+    _callbacks: defaultdict[int, set[str]]
+
+    def __init__(self) -> None:
+        self._callbacks = defaultdict(set)
+
+    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]
+
+
 @asynccontextmanager
 async def lifespan(fapp: FastAPI):
     """
@@ -89,14 +178,31 @@ async def lifespan(fapp: FastAPI):
         )
     )
 
+    # General limiter for async requests
+    fapp.state.llm_request_limiter = AsyncLimiter(
+        max_rate=SERVER_CONFIG.inference.requests_per_minute
+    )
+
+    # Manager for connections and sessions
+    fapp.state.connection_manager = ConnectionManager()
+
+    await fapp.state.connection_manager.initialize(service_config=SERVER_CONFIG)
+
+    # Set up extractors
+    fapp.state.extractors = initialize_extractors(SERVER_CONFIG.extractor)
+
+    # Koji callbacks
+    fapp.state.koji_callback_manager = KojiCallbackManager()
+
     # Ensure that the database is initialized.
     await logdetective.server.database.base.init()
 
     # Start the background task scheduler for collecting emojis
-    asyncio.create_task(schedule_collect_emojis_task())
+    asyncio.create_task(schedule_collect_emojis_task(fapp.state.connection_manager))
 
     yield
 
+    await fapp.state.connection_manager.close()
     await fapp.http.close()
 
 
@@ -144,20 +250,24 @@ app = FastAPI(
     contact={
         "name": "Log Detective developers",
         "url": "https://github.com/fedora-copr/logdetective",
-        "email": "copr-devel@lists.fedorahosted.org"
+        "email": "copr-devel@lists.fedorahosted.org",
     },
     license_info={
         "name": "Apache-2.0",
         "url": "https://www.apache.org/licenses/LICENSE-2.0.html",
     },
     version=get_version(),
-    dependencies=[Depends(requires_token_when_set)], lifespan=lifespan)
+    dependencies=[Depends(requires_token_when_set)],
+    lifespan=lifespan,
+)
 
 
 @app.post("/analyze", response_model=Response)
 @track_request()
 async def analyze_log(
-    build_log: BuildLog, http_session: aiohttp.ClientSession = Depends(get_http_session)
+    build_log: BuildLog,
+    request: Request,
+    http_session: aiohttp.ClientSession = Depends(get_http_session),
 ):
     """Provide endpoint for log file submission and analysis.
     Request must be in form {"url":"<YOUR_URL_HERE>"}.
@@ -168,13 +278,19 @@ async def analyze_log(
     remote_log = RemoteLog(build_log.url, http_session)
     log_text = await remote_log.process_url()
 
-    return await perfrom_analysis(log_text)
+    return await perform_analysis(
+        log_text,
+        async_request_limiter=request.app.state.llm_request_limiter,
+        extractors=request.app.state.extractors
+    )
 
 
 @app.post("/analyze/staged", response_model=StagedResponse)
 @track_request()
 async def analyze_log_staged(
-    build_log: BuildLog, http_session: aiohttp.ClientSession = Depends(get_http_session)
+    build_log: BuildLog,
+    request: Request,
+    http_session: aiohttp.ClientSession = Depends(get_http_session),
 ):
     """Provide endpoint for log file submission and analysis.
     Request must be in form {"url":"<YOUR_URL_HERE>"}.
@@ -185,7 +301,11 @@ async def analyze_log_staged(
     remote_log = RemoteLog(build_log.url, http_session)
     log_text = await remote_log.process_url()
 
-    return await perform_staged_analysis(log_text)
+    return await perform_staged_analysis(
+        log_text,
+        async_request_limiter=request.app.state.llm_request_limiter,
+        extractors=request.app.state.extractors,
+    )
 
 
 @app.get(
@@ -245,10 +365,11 @@ async def get_koji_task_analysis(
 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")],
+    request: Request,
     x_koji_token: Annotated[str, Header()] = "",
     x_koji_callback: Annotated[str, Header()] = "",
     background_tasks: BackgroundTasks = BackgroundTasks(),
-):
+):  # pylint: disable=too-many-arguments disable=too-many-positional-arguments
     """Provide endpoint for retrieving log file analysis of a Koji task"""
 
     try:
@@ -276,16 +397,23 @@ async def analyze_rpmbuild_koji(
         # Task not yet analyzed or it timed out, so we need to start the
         # analysis in the background and return a 202 (Accepted) error.
 
+        koji_connection = request.app.state.connection_manager.koji_connections[
+            koji_instance
+        ]
         background_tasks.add_task(
             analyze_koji_task,
             task_id,
             koji_instance_config,
+            koji_connection,
+            request.app.state.llm_request_limiter,
+            request.app.state.extractors,
+            request.app.state.koji_callback_manager
         )
 
         # 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)
+            request.app.state.koji_callback_manager.register_callback(task_id, x_koji_callback)
 
         response = BasicResponse(
             status_code=202, content=f"Beginning analysis of task {task_id}"
@@ -301,13 +429,19 @@ async def analyze_rpmbuild_koji(
     return response
 
 
-async def analyze_koji_task(task_id: int, koji_instance_config: KojiInstanceConfig):
+async def analyze_koji_task(
+    task_id: int,
+    koji_instance_config: KojiInstanceConfig,
+    koji_connection: ClientSession,
+    async_request_limiter: AsyncLimiter,
+    extractors: list[Extractor],
+    koji_callback_manager: KojiCallbackManager,
+):  # pylint: disable=too-many-arguments disable=too-many-positional-arguments
     """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
+        koji_connection, task_id, max_size=SERVER_CONFIG.koji.max_artifact_size
     )
 
     # We need to handle the metric tracking manually here, because we need
@@ -327,7 +461,11 @@ async def analyze_koji_task(task_id: int, koji_instance_config: KojiInstanceConf
         task_id=task_id,
         log_file_name=log_file_name,
     )
-    response = await perform_staged_analysis(log_text)
+    response = await perform_staged_analysis(
+        log_text,
+        async_request_limiter=async_request_limiter,
+        extractors=extractors
+    )
 
     # Now that we have the response, we can update the metrics and mark the
     # koji task analysis as completed.
@@ -335,12 +473,12 @@ async def analyze_koji_task(task_id: int, koji_instance_config: KojiInstanceConf
     await 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):
+    for callback in koji_callback_manager.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)
+    koji_callback_manager.clear_callbacks(task_id)
 
     return response
 
@@ -353,18 +491,18 @@ async def send_koji_callback(callback: str, task_id: int):
 
 
 @app.get("/queue/print")
-async def queue_print(msg: str):
+async def queue_print(msg: str, request: Request):
     """Debug endpoint to test the LLM request queue"""
     LOG.info("Will print %s", msg)
 
-    result = await async_log(msg)
+    result = await async_log(msg, request)
 
     LOG.info("Printed %s and returned it", result)
 
 
-async def async_log(msg):
+async def async_log(msg: str, request: Request):
     """Debug function to test the LLM request queue"""
-    async with SERVER_CONFIG.inference.get_limiter():
+    async with request.app.state.llm_request_limiter:
         LOG.critical(msg)
     return msg
 
@@ -378,7 +516,9 @@ async def get_version_wrapper():
 @app.post("/analyze/stream", response_class=StreamingResponse)
 @track_request()
 async def analyze_log_stream(
-    build_log: BuildLog, http_session: aiohttp.ClientSession = Depends(get_http_session)
+    build_log: BuildLog,
+    request: Request,
+    http_session: aiohttp.ClientSession = Depends(get_http_session),
 ):
     """Stream response endpoint for Logdetective.
     Request must be in form {"url":"<YOUR_URL_HERE>"}.
@@ -389,7 +529,11 @@ async def analyze_log_stream(
     remote_log = RemoteLog(build_log.url, http_session)
     log_text = await remote_log.process_url()
     try:
-        stream = perform_analyis_stream(log_text)
+        stream = perform_analysis_stream(
+            log_text,
+            async_request_limiter=request.app.state.llm_request_limiter,
+            extractors=request.app.state.extractors,
+        )
     except aiohttp.ClientResponseError as ex:
         raise HTTPException(
             status_code=400,
@@ -421,6 +565,7 @@ def is_valid_webhook_secret(forge, x_gitlab_token):
 async def receive_gitlab_job_event_webhook(
     job_hook: JobHook,
     background_tasks: BackgroundTasks,
+    request: Request,
     x_gitlab_instance: Annotated[str | None, Header()],
     x_gitlab_token: Annotated[str | None, Header()] = None,
 ):
@@ -441,11 +586,21 @@ async def receive_gitlab_job_event_webhook(
 
     # Handle the message in the background so we can return 204 immediately
     gitlab_cfg = SERVER_CONFIG.gitlab.instances[forge.value]
+    gitlab_connection = request.app.state.connection_manager.gitlab_connections[
+        forge.value
+    ]
+    gitlab_http_session = request.app.state.connection_manager.gitlab_http_sessions[
+        forge.value
+    ]
     background_tasks.add_task(
         process_gitlab_job_event,
         gitlab_cfg,
+        gitlab_connection,
+        gitlab_http_session,
         forge,
         job_hook,
+        request.app.state.llm_request_limiter,
+        request.app.state.extractors
     )
 
     # No return value or body is required for a webhook.
@@ -467,6 +622,7 @@ async def receive_gitlab_emoji_event_webhook(
     x_gitlab_token: Annotated[str | None, Header()],
     emoji_hook: EmojiHook,
     background_tasks: BackgroundTasks,
+    request: Request,
 ):
     """Webhook endpoint for receiving emoji event notifications from Gitlab
     https://docs.gitlab.com/user/project/integrations/webhook_events/#emoji-events
@@ -519,10 +675,14 @@ async def receive_gitlab_emoji_event_webhook(
     # Inform the lookup table that we are processing this emoji
     emoji_lookup[key] = False
 
+    gitlab_connection = request.app.state.connection_manager.gitlab_connections[
+        x_gitlab_instance
+    ]
     # Create a background task to process the emojis on this Merge Request.
     background_tasks.add_task(
         schedule_emoji_collection_for_mr,
         forge,
+        gitlab_connection,
         emoji_hook.merge_request.target_project_id,
         emoji_hook.merge_request.iid,
         background_tasks,
@@ -534,17 +694,21 @@ async def receive_gitlab_emoji_event_webhook(
 
 
 async def schedule_emoji_collection_for_mr(
-    forge: Forge, project_id: int, mr_iid: int, background_tasks: BackgroundTasks
+    forge: Forge,
+    gitlab_connection: Gitlab,
+    project_id: int,
+    mr_iid: int,
+    background_tasks: BackgroundTasks,
 ):
     """Background task to update the database on emoji reactions"""
 
     key = (forge, project_id, mr_iid)
 
     # FIXME: Look up the connection from the Forge  # pylint: disable=fixme
-    gitlab_conn = SERVER_CONFIG.gitlab.instances[forge.value].get_connection()
+    # gitlab_conn = SERVER_CONFIG.gitlab.instances[forge.value].get_connection()
 
     LOG.debug("Looking up emojis for %s, %d, %d", forge, project_id, mr_iid)
-    await collect_emojis_for_mr(project_id, mr_iid, gitlab_conn)
+    await collect_emojis_for_mr(project_id, mr_iid, gitlab_connection)
 
     # Check whether we've been asked to re-schedule this lookup because
     # another request came in while it was processing.
@@ -555,6 +719,7 @@ async def schedule_emoji_collection_for_mr(
         background_tasks.add_task(
             schedule_emoji_collection_for_mr,
             forge,
+            gitlab_connection,
             project_id,
             mr_iid,
             background_tasks,
@@ -677,25 +842,27 @@ async def get_metrics(
     return await handler()
 
 
-async def collect_emoji_task():
+async def collect_emoji_task(connection_manager: ConnectionManager):
     """Collect emoji feedback.
     Query only comments created in the last year.
     """
 
-    for instance in SERVER_CONFIG.gitlab.instances.values():
+    for instance_url, instance in SERVER_CONFIG.gitlab.instances.items():
         LOG.info(
             "Collect emoji feedback for %s started at %s",
             instance.url,
             datetime.datetime.now(datetime.timezone.utc),
         )
-        await collect_emojis(instance.get_connection(), TimePeriod(weeks=54))
+        await collect_emojis(
+            connection_manager.gitlab_connections[instance_url], TimePeriod(weeks=54)
+        )
         LOG.info(
             "Collect emoji feedback finished at %s",
             datetime.datetime.now(datetime.timezone.utc),
         )
 
 
-async def schedule_collect_emojis_task():
+async def schedule_collect_emojis_task(connection_manager: ConnectionManager):
     """Schedule the collect_emojis_task to run on a configured interval"""
     while True:
         seconds_until_run = SERVER_CONFIG.general.collect_emojis_interval
@@ -703,6 +870,6 @@ async def schedule_collect_emojis_task():
         await asyncio.sleep(seconds_until_run)
 
         try:
-            await collect_emoji_task()
+            await collect_emoji_task(connection_manager=connection_manager)
         except Exception as e:  # pylint: disable=broad-exception-caught
             LOG.exception("Error in collect_emoji_task: %s", e)

{logdetective-2.11.0.dist-info → logdetective-2.13.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logdetective
-Version: 2.11.0
+Version: 2.13.0
 Summary: Log using LLM AI to search for build/test failures and provide ideas for fixing these.
 License: Apache-2.0
 License-File: LICENSE
@@ -24,7 +24,7 @@ Provides-Extra: server
 Provides-Extra: server-testing
 Provides-Extra: testing
 Requires-Dist: aiohttp (>=3.7.4,<4.0.0)
-Requires-Dist: aiolimiter (>=1.0.0,<2.0.0) ; extra == "server"
+Requires-Dist: aiolimiter (>=1.0.0,<2.0.0) ; extra == "server" or extra == "server-testing"
 Requires-Dist: aioresponses (>=0.7.8,<0.8.0) ; extra == "testing"
 Requires-Dist: alembic (>=1.13.3,<2.0.0) ; extra == "server" or extra == "server-testing"
 Requires-Dist: asciidoc[testing] (>=10.2.1,<11.0.0) ; extra == "testing"

{logdetective-2.11.0.dist-info → logdetective-2.13.0.dist-info}/RECORD

@@ -10,9 +10,9 @@ logdetective/prompts.yml,sha256=i3z6Jcb4ScVi7LsxOpDlKiXrcvql3qO_JnLzkAKMn1c,3870
 logdetective/remote_log.py,sha256=28QvdQiy7RBnd86EKCq_A75P21gSNlCbgxJe5XAe9MA,2258
 logdetective/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 logdetective/server/compressors.py,sha256=y4aFYJ_9CbYdKuAI39Kc9GQSdPN8cSJ2c_VAz3T47EE,5249
-logdetective/server/config.py,sha256=cKUmNCJyNyEid0bPTiUjr8CQuBYBab5bC79Axk2h0z8,2525
+logdetective/server/config.py,sha256=dYoqvexnMo8LBXhXezMIEqUwzTsRD-eWvRIFIYNv388,2540
 logdetective/server/database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-logdetective/server/database/base.py,sha256=HSV2tgye7iYTDzJD1Q5X7_nlLuTMIFP-hRVQMYxngHQ,2073
+logdetective/server/database/base.py,sha256=bqMkhL2D96i_QiSnO5u1FqxYuJJu0m0wXLkqj_A9WBs,2093
 logdetective/server/database/models/__init__.py,sha256=zoZMCt1_7tewDa6eEIIX_xrdN-tLegSiPNg5NiYaV3o,850
 logdetective/server/database/models/exceptions.py,sha256=4ED7FSSA1liV9-7VIN2BwUiz6XlmP97Y1loKnsoNdD8,507
 logdetective/server/database/models/koji.py,sha256=HNWxHYDxf4JN9K2ue8-V8dH-0XY5ZmxqH7Y9lAIbILA,6436
@@ -20,21 +20,21 @@ logdetective/server/database/models/merge_request_jobs.py,sha256=MxiAVKQIsQMbFyl
 logdetective/server/database/models/metrics.py,sha256=4xsUdbtlp5PI1-iJQc5Dd8EPDgVVplD9hJRWeRDn43k,15443
 logdetective/server/emoji.py,sha256=zSaYtLpSkpRCXpjMWnHR1bYwkmobMJASZ7YNalrd85U,5274
 logdetective/server/exceptions.py,sha256=WN715KLL3ya6FiZ95v70VSbNuVhGuHFzxm2OeEPWQCw,981
-logdetective/server/gitlab.py,sha256=putpnf8PfGsCZJsqWZA1rMovRGnyagoQmgpKLqtA-aQ,16743
+logdetective/server/gitlab.py,sha256=X9JSotUUlG9bOWYbUNKt9KqLUAj6Uocd2KNpfn35ccU,17192
 logdetective/server/koji.py,sha256=LG1pRiKUFvYFRKzgQoUG3pUHfcEwMoaMNjUSMKw_pBA,5640
-logdetective/server/llm.py,sha256=bmA6LsV80OdO60q4WLoKuehuVDEYq-HhBAYcZeLfrv8,10150
+logdetective/server/llm.py,sha256=wHMxRbAjI0q3osR5mRDR1kqww_6Pkc7JpF1mh9e6Mg8,10855
 logdetective/server/metric.py,sha256=wLOpgcAch3rwhPA5P2YWUeMNAPsvRGseRjH5HlTb7JM,4529
-logdetective/server/models.py,sha256=AJyycAEEl2o6TH4eAqVMlt5woqAB5M8ze2L575leA_I,19835
+logdetective/server/models.py,sha256=iJ-5UgScKKSRL8fRCsM23Z34P3p98LaduwWO-q9rudo,13041
 logdetective/server/plot.py,sha256=8LERgY3vQckaHZV2PZfOrZT8CjCAiji57QCmRW24Rfo,14697
-logdetective/server/server.py,sha256=JueU-5c8t9h1CZy4gtoEeT8VSEirpeS0K3wrfqTPvAc,25381
+logdetective/server/server.py,sha256=AM10P72tc_7N0GhH_N7msFhLr7ZGNgIfgTxt2sjasVE,30982
 logdetective/server/templates/base_response.html.j2,sha256=BJGGV_Xb0Lnue8kq32oG9lI5CQDf9vce7HMYsP-Pvb4,2040
 logdetective/server/templates/gitlab_full_comment.md.j2,sha256=4UujUzl3lmdbNEADsxn3HVrjfUiUu2FvUlp9MDFGXQI,2321
 logdetective/server/templates/gitlab_short_comment.md.j2,sha256=2krnMlGqqju2V_6pE0UqUR1P674OFaeX5BMyY5htTOQ,2022
 logdetective/server/utils.py,sha256=0BZ8WmzXNEtkUty1kOyFbBxDZWL0Icc8BUrxuHw9uvs,4015
 logdetective/skip_snippets.yml,sha256=reGlhPPCo06nNUJWiC2LY-OJOoPdcyOB7QBTSMeh0eg,487
 logdetective/utils.py,sha256=yalhySOF_Gzmqx_Ft9qad3TplAfZ6LOmauGXEJfKWiE,9803
-logdetective-2.11.0.dist-info/METADATA,sha256=SdXBkYlSoiVXhgPiM23luYQa0Y_BCX_el_mxTdJc0Zw,23273
-logdetective-2.11.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-logdetective-2.11.0.dist-info/entry_points.txt,sha256=3K_vXja6PmcA8sNdUi63WdImeiNhVZcEGPTaoJmltfA,63
-logdetective-2.11.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-logdetective-2.11.0.dist-info/RECORD,,
+logdetective-2.13.0.dist-info/METADATA,sha256=uwiSy7i6qIvLUxz-J5hCqzlLWWqmdAsi0IIvrGgQmMs,23302
+logdetective-2.13.0.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
+logdetective-2.13.0.dist-info/entry_points.txt,sha256=3K_vXja6PmcA8sNdUi63WdImeiNhVZcEGPTaoJmltfA,63
+logdetective-2.13.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+logdetective-2.13.0.dist-info/RECORD,,

{logdetective-2.11.0.dist-info → logdetective-2.13.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.2.1
+Generator: poetry-core 2.3.0
 Root-Is-Purelib: true
 Tag: py3-none-any