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

logdetective/server/llm.py

@@ -1,6 +1,7 @@
 import os
 import asyncio
 import random
+import time
 from typing import List, Tuple, Dict
 
 import backoff
@@ -15,6 +16,7 @@ from logdetective.utils import (
     compute_certainty,
     prompt_to_messages,
     format_snippets,
+    mine_logs,
 )
 from logdetective.server.config import (
     LOG,
@@ -33,10 +35,10 @@ from logdetective.server.models import (
 )
 from logdetective.server.utils import (
     format_analyzed_snippets,
-    mine_logs,
     should_we_giveup,
     we_give_up,
     filter_snippets,
+    construct_final_prompt,
 )
 
 
@@ -184,10 +186,13 @@ async def analyze_snippets(
 
 async def perfrom_analysis(log_text: str) -> Response:
     """Sumbit log file snippets in aggregate to LLM and retrieve results"""
-    log_summary = mine_logs(log_text)
+    log_summary = mine_logs(log_text, SERVER_CONFIG.extractor.get_extractors())
     log_summary = format_snippets(log_summary)
+
+    final_prompt = construct_final_prompt(log_summary, PROMPT_CONFIG.prompt_template)
+
     messages = prompt_to_messages(
-        PROMPT_CONFIG.prompt_template.format(log_summary),
+        final_prompt,
         PROMPT_CONFIG.default_system_prompt,
         SERVER_CONFIG.inference.system_role,
         SERVER_CONFIG.inference.user_role,
@@ -213,10 +218,13 @@ async def perfrom_analysis(log_text: str) -> Response:
 
 async def perform_analyis_stream(log_text: str) -> AsyncStream:
     """Submit log file snippets in aggregate and return a stream of tokens"""
-    log_summary = mine_logs(log_text)
+    log_summary = mine_logs(log_text, SERVER_CONFIG.extractor.get_extractors())
     log_summary = format_snippets(log_summary)
+
+    final_prompt = construct_final_prompt(log_summary, PROMPT_CONFIG.prompt_template)
+
     messages = prompt_to_messages(
-        PROMPT_CONFIG.prompt_template.format(log_summary),
+        final_prompt,
         PROMPT_CONFIG.default_system_prompt,
         SERVER_CONFIG.inference.system_role,
         SERVER_CONFIG.inference.user_role,
@@ -235,8 +243,8 @@ async def perform_analyis_stream(log_text: str) -> AsyncStream:
 
 async def perform_staged_analysis(log_text: str) -> StagedResponse:
     """Submit the log file snippets to the LLM and retrieve their results"""
-    log_summary = mine_logs(log_text)
-
+    log_summary = mine_logs(log_text, SERVER_CONFIG.extractor.get_extractors())
+    start = time.time()
     if SERVER_CONFIG.general.top_k_snippets:
         rated_snippets = await analyze_snippets(
             log_summary=log_summary,
@@ -265,10 +273,11 @@ async def perform_staged_analysis(log_text: str) -> StagedResponse:
             AnalyzedSnippet(line_number=e[0][0], text=e[0][1], explanation=e[1])
             for e in zip(log_summary, processed_snippets)
         ]
+    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 = PROMPT_CONFIG.prompt_template_staged.format(
-        format_analyzed_snippets(processed_snippets)
-    )
     messages = prompt_to_messages(
         final_prompt,
         PROMPT_CONFIG.staged_system_prompt,

logdetective/server/metric.py

@@ -1,4 +1,3 @@
-import io
 import inspect
 import datetime
 
@@ -13,14 +12,15 @@ from logdetective.remote_log import RemoteLog
 from logdetective.server.config import LOG
 from logdetective.server.compressors import LLMResponseCompressor, RemoteLogCompressor
 from logdetective.server.database.models import EndpointType, AnalyzeRequestMetrics
+from logdetective.server.exceptions import LogDetectiveMetricsError
 
 
 async def add_new_metrics(
-    api_name: str,
+    api_name: EndpointType,
     url: Optional[str] = None,
     http_session: Optional[aiohttp.ClientSession] = None,
     received_at: Optional[datetime.datetime] = None,
-    compressed_log_content: Optional[io.BytesIO] = None,
+    compressed_log_content: Optional[bytes] = None,
 ) -> int:
     """Add a new database entry for a received request.
 
@@ -29,10 +29,14 @@ async def add_new_metrics(
     and the log (in a zip format) for which analysis is requested.
     """
     if not compressed_log_content:
+        if not (url and http_session):
+            raise LogDetectiveMetricsError(
+                f"""Remote log can not be retrieved without URL and http session.
+                URL: {url}, http session:{http_session}""")
         remote_log = RemoteLog(url, http_session)
         compressed_log_content = await RemoteLogCompressor(remote_log).zip_content()
 
-    return AnalyzeRequestMetrics.create(
+    return await AnalyzeRequestMetrics.create(
         endpoint=EndpointType(api_name),
         compressed_log=compressed_log_content,
         request_received_at=received_at
@@ -41,7 +45,7 @@ async def add_new_metrics(
     )
 
 
-def update_metrics(
+async def update_metrics(
     metrics_id: int,
     response: Union[models.Response, models.StagedResponse, StreamingResponse],
     sent_at: Optional[datetime.datetime] = None,
@@ -73,12 +77,12 @@ def update_metrics(
     response_certainty = (
         response.response_certainty if hasattr(response, "response_certainty") else None
     )
-    AnalyzeRequestMetrics.update(
-        metrics_id,
-        response_sent_at,
-        response_length,
-        response_certainty,
-        compressed_response,
+    await AnalyzeRequestMetrics.update(
+        id_=metrics_id,
+        response_sent_at=response_sent_at,
+        response_length=response_length,
+        response_certainty=response_certainty,
+        compressed_response=compressed_response,
     )
 
 
@@ -109,10 +113,11 @@ def track_request(name=None):
         async def async_decorated_function(*args, **kwargs):
             log_url = kwargs["build_log"].url
             metrics_id = await add_new_metrics(
-                name if name else f.__name__, log_url, kwargs["http_session"]
+                api_name=EndpointType(name if name else f.__name__),
+                url=log_url, http_session=kwargs["http_session"]
             )
             response = await f(*args, **kwargs)
-            update_metrics(metrics_id, response)
+            await update_metrics(metrics_id, response)
             return response
 
         if inspect.iscoroutinefunction(f):

logdetective/server/models.py

@@ -10,6 +10,7 @@ from pydantic import (
     field_validator,
     NonNegativeFloat,
     HttpUrl,
+    PrivateAttr,
 )
 
 import aiohttp
@@ -26,6 +27,9 @@ from logdetective.constants import (
     USER_ROLE_DEFAULT,
 )
 
+from logdetective.extractors import Extractor, DrainExtractor, CSGrepExtractor
+from logdetective.utils import check_csgrep
+
 
 class BuildLog(BaseModel):
     """Model of data submitted to API."""
@@ -179,8 +183,9 @@ class InferenceConfig(BaseModel):  # pylint: disable=too-many-instance-attribute
     http_timeout: float = 5.0
     user_role: str = USER_ROLE_DEFAULT
     system_role: str = SYSTEM_ROLE_DEFAULT
-    _http_session: aiohttp.ClientSession = None
-    _limiter: AsyncLimiter = AsyncLimiter(LLM_DEFAULT_REQUESTS_PER_MINUTE)
+    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__()
@@ -200,42 +205,9 @@ class InferenceConfig(BaseModel):  # pylint: disable=too-many-instance-attribute
         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 __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
-
-    def get_http_session(self):
-        """Return the internal HTTP session so it can be used to contect the
-        LLM 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,
-                timeout=aiohttp.ClientTimeout(
-                    total=self.http_timeout,
-                    connect=3.07,
-                ),
-            )
-
-        return self._http_session
-
     def get_limiter(self):
         """Return the limiter object so it can be used as a context manager"""
         return self._limiter
@@ -244,20 +216,59 @@ class InferenceConfig(BaseModel):  # pylint: disable=too-many-instance-attribute
 class ExtractorConfig(BaseModel):
     """Model for extractor configuration of logdetective server."""
 
-    context: bool = True
     max_clusters: int = 8
     verbose: bool = False
     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__()
+        super().__init__(data=data)
+
         if data is None:
+            self._setup_extractors()
             return
 
-        self.context = data.get("context", True)
         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")
+    @classmethod
+    def validate_csgrep(cls, value: bool) -> bool:
+        """Verify that csgrep is available if requested."""
+        if not check_csgrep():
+            raise ValueError(
+                "Requested csgrep extractor but `csgrep` binary is not in the PATH"
+            )
+        return value
 
 
 class GitLabInstanceConfig(BaseModel):  # pylint: disable=too-many-instance-attributes
@@ -265,6 +276,7 @@ class GitLabInstanceConfig(BaseModel):  # pylint: disable=too-many-instance-attr
 
     name: str = None
     url: str = None
+    # Path to API of the gitlab instance, assuming `url` as prefix.
     api_path: str = None
     api_token: str = None
 
@@ -277,8 +289,8 @@ class GitLabInstanceConfig(BaseModel):  # pylint: disable=too-many-instance-attr
     webhook_secrets: Optional[List[str]] = None
 
     timeout: float = 5.0
-    _conn: Gitlab = None
-    _http_session: aiohttp.ClientSession = None
+    _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
@@ -364,8 +376,8 @@ class KojiInstanceConfig(BaseModel):
     xmlrpc_url: str = ""
     tokens: List[str] = []
 
-    _conn: Optional[koji.ClientSession] = None
-    _callbacks: defaultdict[int, set[str]] = defaultdict(set)
+    _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__()
@@ -455,8 +467,8 @@ class LogConfig(BaseModel):
 class GeneralConfig(BaseModel):
     """General config options for Log Detective"""
 
-    packages: List[str] = None
-    excluded_packages: List[str] = None
+    packages: List[str] = []
+    excluded_packages: List[str] = []
     devmode: bool = False
     sentry_dsn: HttpUrl | None = None
     collect_emojis_interval: int = 60 * 60  # seconds
@@ -483,6 +495,7 @@ class Config(BaseModel):
     log: LogConfig = LogConfig()
     inference: InferenceConfig = InferenceConfig()
     snippet_inference: InferenceConfig = InferenceConfig()
+    # TODO(jpodivin): Extend to work with multiple extractor configs
     extractor: ExtractorConfig = ExtractorConfig()
     gitlab: GitLabConfig = GitLabConfig()
     koji: KojiConfig = KojiConfig()
@@ -522,7 +535,8 @@ class TimePeriod(BaseModel):
     @model_validator(mode="before")
     @classmethod
     def check_exclusive_fields(cls, data):
-        """Check that only one key between weeks, days and hours is defined"""
+        """Check that only one key between weeks, days and hours is defined,
+        if no period is specified, fall back to 2 days."""
         if isinstance(data, dict):
             how_many_fields = sum(
                 1
@@ -548,6 +562,7 @@ class TimePeriod(BaseModel):
 
     def get_time_period(self) -> datetime.timedelta:
         """Get the period of time represented by this input model.
+        Will default to 2 days, if no period is set.
 
         Returns:
             datetime.timedelta: The time period as a timedelta object.
@@ -559,10 +574,12 @@ class TimePeriod(BaseModel):
             delta = datetime.timedelta(days=self.days)
         elif self.hours:
             delta = datetime.timedelta(hours=self.hours)
+        else:
+            delta = datetime.timedelta(days=2)
         return delta
 
     def get_period_start_time(
-        self, end_time: datetime.datetime = None
+        self, end_time: Optional[datetime.datetime] = None
     ) -> datetime.datetime:
         """Calculate the start time of this period based on the end time.
 
@@ -575,5 +592,5 @@ class TimePeriod(BaseModel):
         """
         time = end_time or datetime.datetime.now(datetime.timezone.utc)
         if time.tzinfo is None:
-            end_time = end_time.replace(tzinfo=datetime.timezone.utc)
+            time = time.replace(tzinfo=datetime.timezone.utc)
         return time - self.get_time_period()

logdetective/server/plot.py

@@ -69,7 +69,7 @@ def create_time_series_arrays(
     plot_def: Definition,
     start_time: datetime.datetime,
     end_time: datetime.datetime,
-    value_type: Optional[Union[int, float]] = int,
+    value_type: Optional[Union[type[int], type[float]]] = int,
 ) -> tuple[numpy.ndarray, numpy.ndarray]:
     """Create time series arrays from a dictionary of values.
 
@@ -163,7 +163,7 @@ def _add_line_chart(  # pylint: disable=too-many-arguments disable=too-many-posi
         ax.tick_params(axis="y", labelcolor=color)
 
 
-def requests_per_time(
+async def requests_per_time(
     period_of_time: TimePeriod,
     endpoint: EndpointType = EndpointType.ANALYZE,
     end_time: Optional[datetime.datetime] = None,
@@ -191,7 +191,7 @@ def requests_per_time(
     end_time = end_time or datetime.datetime.now(datetime.timezone.utc)
     start_time = period_of_time.get_period_start_time(end_time)
     plot_def = Definition(period_of_time)
-    requests_counts = AnalyzeRequestMetrics.get_requests_in_period(
+    requests_counts = await AnalyzeRequestMetrics.get_requests_in_period(
         start_time, end_time, plot_def.time_format, endpoint
     )
     timestamps, counts = create_time_series_arrays(
@@ -218,7 +218,7 @@ def requests_per_time(
     return fig
 
 
-def average_time_per_responses(  # pylint: disable=too-many-locals
+async def average_time_per_responses(  # pylint: disable=too-many-locals
     period_of_time: TimePeriod,
     endpoint: EndpointType = EndpointType.ANALYZE,
     end_time: Optional[datetime.datetime] = None,
@@ -246,8 +246,10 @@ def average_time_per_responses(  # pylint: disable=too-many-locals
     end_time = end_time or datetime.datetime.now(datetime.timezone.utc)
     start_time = period_of_time.get_period_start_time(end_time)
     plot_def = Definition(period_of_time)
-    responses_average_time = AnalyzeRequestMetrics.get_responses_average_time_in_period(
-        start_time, end_time, plot_def.time_format, endpoint
+    responses_average_time = (
+        await AnalyzeRequestMetrics.get_responses_average_time_in_period(
+            start_time, end_time, plot_def.time_format, endpoint
+        )
     )
     timestamps, average_time = create_time_series_arrays(
         responses_average_time,
@@ -263,7 +265,7 @@ def average_time_per_responses(  # pylint: disable=too-many-locals
     )
 
     responses_average_length = (
-        AnalyzeRequestMetrics.get_responses_average_length_in_period(
+        await AnalyzeRequestMetrics.get_responses_average_length_in_period(
             start_time, end_time, plot_def.time_format, endpoint
         )
     )
@@ -292,7 +294,7 @@ def average_time_per_responses(  # pylint: disable=too-many-locals
     return fig
 
 
-def _collect_emoji_data(
+async def _collect_emoji_data(
     start_time: datetime.datetime, plot_def: Definition
 ) -> Dict[str, Dict[datetime.datetime, int]]:
     """Collect and organize emoji feedback data
@@ -300,7 +302,7 @@ def _collect_emoji_data(
     Counts all emojis given to logdetective comments created since start_time.
     Collect counts in time accordingly to the plot definition.
     """
-    reactions = Reactions.get_since(start_time)
+    reactions = await Reactions.get_since(start_time)
     reactions_values_dict: Dict[str, Dict] = {}
     for comment_created_at, reaction in reactions:
         comment_created_at_formatted = comment_created_at.strptime(
@@ -369,7 +371,7 @@ def _plot_emoji_data(  # pylint: disable=too-many-locals
     return emoji_lines, emoji_labels
 
 
-def emojis_per_time(
+async def emojis_per_time(
     period_of_time: TimePeriod,
     end_time: Optional[datetime.datetime] = None,
 ) -> figure.Figure:
@@ -395,7 +397,7 @@ def emojis_per_time(
     plot_def = Definition(period_of_time)
     end_time = end_time or datetime.datetime.now(datetime.timezone.utc)
     start_time = period_of_time.get_period_start_time(end_time)
-    reactions_values_dict = _collect_emoji_data(start_time, plot_def)
+    reactions_values_dict = await _collect_emoji_data(start_time, plot_def)
 
     fig, ax = pyplot.subplots(figsize=(12, 6))
 

logdetective/server/server.py

@@ -67,6 +67,7 @@ from logdetective.server.emoji import (
     collect_emojis_for_mr,
 )
 from logdetective.server.compressors import RemoteLogCompressor
+from logdetective.server.utils import get_version
 
 
 LOG_SOURCE_REQUEST_TIMEOUT = os.environ.get("LOG_SOURCE_REQUEST_TIMEOUT", 60)
@@ -89,7 +90,7 @@ async def lifespan(fapp: FastAPI):
     )
 
     # Ensure that the database is initialized.
-    logdetective.server.database.base.init()
+    await logdetective.server.database.base.init()
 
     # Start the background task scheduler for collecting emojis
     asyncio.create_task(schedule_collect_emojis_task())
@@ -106,37 +107,51 @@ async def get_http_session(request: Request) -> aiohttp.ClientSession:
     return request.app.http
 
 
-def requires_token_when_set(authentication: Annotated[str | None, Header()] = None):
+def requires_token_when_set(authorization: Annotated[str | None, Header()] = None):
     """
-    FastAPI Depend function that expects a header named Authentication
+    FastAPI Depend function that expects a header named Authorization
 
     If LOGDETECTIVE_TOKEN env var is set, validate the client-supplied token
     otherwise ignore it
     """
     if not API_TOKEN:
-        LOG.info("LOGDETECTIVE_TOKEN env var not set, authentication disabled")
+        LOG.info("LOGDETECTIVE_TOKEN env var not set, authorization disabled")
         # no token required, means local dev environment
         return
-    token = None
-    if authentication:
+    if authorization:
         try:
-            token = authentication.split(" ", 1)[1]
-        except (ValueError, IndexError):
+            token = authorization.split(" ", 1)[1]
+        except (ValueError, IndexError) as ex:
             LOG.warning(
-                "Authentication header has invalid structure (%s), it should be 'Bearer TOKEN'",
-                authentication,
+                "Authorization header has invalid structure '%s', it should be 'Bearer TOKEN'",
+                authorization,
             )
             # eat the exception and raise 401 below
-            token = None
+            raise HTTPException(
+                status_code=401,
+                detail=f"Invalid authorization, HEADER '{authorization}' not valid.",
+            ) from ex
         if token == API_TOKEN:
             return
-    LOG.info(
-        "LOGDETECTIVE_TOKEN env var is set (%s), clien token = %s", API_TOKEN, token
-    )
-    raise HTTPException(status_code=401, detail=f"Token {token} not valid.")
-
-
-app = FastAPI(dependencies=[Depends(requires_token_when_set)], lifespan=lifespan)
+        LOG.info("Provided token '%s' does not match expected value.", token)
+        raise HTTPException(status_code=401, detail=f"Token '{token}' not valid.")
+    LOG.error("No authorization header provided but LOGDETECTIVE_TOKEN env var is set")
+    raise HTTPException(status_code=401, detail="No token provided.")
+
+
+app = FastAPI(
+    title="Log Detective",
+    contact={
+        "name": "Log Detective developers",
+        "url": "https://github.com/fedora-copr/logdetective",
+        "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)
 
 
 @app.post("/analyze", response_model=Response)
@@ -299,16 +314,15 @@ async def analyze_koji_task(task_id: int, koji_instance_config: KojiInstanceConf
     # to retrieve the metric ID to associate it with the koji task analysis.
 
     metrics_id = await add_new_metrics(
-        "analyze_koji_task",
+        EndpointType.ANALYZE_KOJI_TASK,
         log_text,
         received_at=datetime.datetime.now(datetime.timezone.utc),
         compressed_log_content=RemoteLogCompressor.zip_text(log_text),
     )
-
     # We need to associate the metric ID with the koji task analysis.
     # This will create the new row without a response, which we will use as
     # an indicator that the analysis is in progress.
-    KojiTaskAnalysis.create_or_restart(
+    await KojiTaskAnalysis.create_or_restart(
         koji_instance=koji_instance_config.xmlrpc_url,
         task_id=task_id,
         log_file_name=log_file_name,
@@ -317,8 +331,8 @@ async def analyze_koji_task(task_id: int, koji_instance_config: KojiInstanceConf
 
     # Now that we have the response, we can update the metrics and mark the
     # koji task analysis as completed.
-    update_metrics(metrics_id, response)
-    KojiTaskAnalysis.add_response(task_id, metrics_id)
+    await update_metrics(metrics_id, response)
+    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):
@@ -355,6 +369,12 @@ async def async_log(msg):
     return msg
 
 
+@app.get("/version", response_class=BasicResponse)
+async def get_version_wrapper():
+    """Get the version of logdetective"""
+    return BasicResponse(content=get_version())
+
+
 @app.post("/analyze/stream", response_class=StreamingResponse)
 @track_request()
 async def analyze_log_stream(
@@ -521,7 +541,7 @@ async def schedule_emoji_collection_for_mr(
     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]
+    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)
@@ -614,22 +634,24 @@ async def get_metrics(
     async def handler():
         """Show statistics for the specified endpoint and plot."""
         if plot == Plot.REQUESTS:
-            fig = plot_engine.requests_per_time(period_since_now, endpoint_type)
+            fig = await plot_engine.requests_per_time(period_since_now, endpoint_type)
             return _svg_figure_response(fig)
         if plot == Plot.RESPONSES:
-            fig = plot_engine.average_time_per_responses(
+            fig = await plot_engine.average_time_per_responses(
                 period_since_now, endpoint_type
             )
             return _svg_figure_response(fig)
         if plot == Plot.EMOJIS:
-            fig = plot_engine.emojis_per_time(period_since_now)
+            fig = await plot_engine.emojis_per_time(period_since_now)
             return _svg_figure_response(fig)
         # BOTH
-        fig_requests = plot_engine.requests_per_time(period_since_now, endpoint_type)
-        fig_responses = plot_engine.average_time_per_responses(
+        fig_requests = await plot_engine.requests_per_time(
+            period_since_now, endpoint_type
+        )
+        fig_responses = await plot_engine.average_time_per_responses(
             period_since_now, endpoint_type
         )
-        fig_emojis = plot_engine.emojis_per_time(period_since_now)
+        fig_emojis = await plot_engine.emojis_per_time(period_since_now)
         return _multiple_svg_figures_response([fig_requests, fig_responses, fig_emojis])
 
     descriptions = {