logdetective 0.6.0__py3-none-any.whl → 0.9.1__py3-none-any.whl

logdetective/server/server.py

@@ -3,15 +3,17 @@ import json
 import os
 import re
 import zipfile
+from enum import Enum
 from contextlib import asynccontextmanager
 from pathlib import Path, PurePath
 from tempfile import TemporaryFile
-from typing import List, Annotated, Tuple, Dict, Any
+from typing import List, Annotated, Tuple, Dict, Any, Union
 from io import BytesIO
 
-
+import backoff
 import matplotlib
 import matplotlib.pyplot
+from aiohttp import StreamReader
 from fastapi import FastAPI, HTTPException, BackgroundTasks, Depends, Header, Request
 
 from fastapi.responses import StreamingResponse
@@ -21,20 +23,23 @@ import gitlab.v4
 import gitlab.v4.objects
 import jinja2
 import aiohttp
+import sqlalchemy
+import sentry_sdk
+
+import logdetective.server.database.base
 
 from logdetective.extractors import DrainExtractor
 from logdetective.utils import (
     compute_certainty,
     format_snippets,
     load_prompts,
-    get_url_content,
 )
 from logdetective.server.utils import (
     load_server_config,
     get_log,
     format_analyzed_snippets,
 )
-from logdetective.server.metric import track_request
+from logdetective.server.metric import track_request, add_new_metrics, update_metrics
 from logdetective.server.models import (
     BuildLog,
     JobHook,
@@ -44,8 +49,14 @@ from logdetective.server.models import (
     AnalyzedSnippet,
     TimePeriod,
 )
-from logdetective.server import plot
-from logdetective.server.database.models import EndpointType
+from logdetective.server import plot as plot_engine
+from logdetective.server.remote_log import RemoteLog
+from logdetective.server.database.models import (
+    Comments,
+    EndpointType,
+    Forge,
+)
+from logdetective.server.database.models import AnalyzeRequestMetrics
 
 LLM_CPP_SERVER_TIMEOUT = os.environ.get("LLAMA_CPP_SERVER_TIMEOUT", 600)
 LOG_SOURCE_REQUEST_TIMEOUT = os.environ.get("LOG_SOURCE_REQUEST_TIMEOUT", 60)
@@ -61,6 +72,9 @@ FAILURE_LOG_REGEX = re.compile(r"(\w*\.log)")
 
 LOG = get_log(SERVER_CONFIG)
 
+if sentry_dsn := SERVER_CONFIG.general.sentry_dsn:
+    sentry_sdk.init(dsn=str(sentry_dsn), traces_sample_rate=1.0)
+
 
 @asynccontextmanager
 async def lifespan(fapp: FastAPI):
@@ -72,6 +86,10 @@ async def lifespan(fapp: FastAPI):
             total=int(LOG_SOURCE_REQUEST_TIMEOUT), connect=3.07
         )
     )
+
+    # Ensure that the database is initialized.
+    logdetective.server.database.base.init()
+
     yield
     await fapp.http.close()
 
@@ -119,16 +137,6 @@ app.gitlab_conn = gitlab.Gitlab(
 )
 
 
-async def process_url(http: aiohttp.ClientSession, url: str) -> str:
-    """Validate log URL and return log text."""
-    try:
-        return await get_url_content(http, url, timeout=int(LOG_SOURCE_REQUEST_TIMEOUT))
-    except RuntimeError as ex:
-        raise HTTPException(
-            status_code=400, detail=f"We couldn't obtain the logs: {ex}"
-        ) from ex
-
-
 def mine_logs(log: str) -> List[Tuple[int, str]]:
     """Extract snippets from log text"""
     extractor = DrainExtractor(
@@ -161,26 +169,19 @@ async def submit_to_llm_endpoint(
     stream:
     """
     LOG.debug("async request %s headers=%s data=%s", url, headers, data)
-    try:
-        response = await http.post(
-            url,
-            headers=headers,
-            # we need to use the `json=` parameter here and let aiohttp
-            # handle the json-encoding
-            json=data,
-            timeout=int(LLM_CPP_SERVER_TIMEOUT),
-            # Docs says chunked takes int, but:
-            #   DeprecationWarning: Chunk size is deprecated #1615
-            # So let's make sure we either put True or None here
-            chunked=True if stream else None,
-            raise_for_status=True,
-        )
-    except aiohttp.ClientResponseError as ex:
-        raise HTTPException(
-            status_code=400,
-            detail="HTTP Error while getting response from inference server "
-            f"[{ex.status}] {ex.message}",
-        ) from ex
+    response = await http.post(
+        url,
+        headers=headers,
+        # we need to use the `json=` parameter here and let aiohttp
+        # handle the json-encoding
+        json=data,
+        timeout=int(LLM_CPP_SERVER_TIMEOUT),
+        # Docs says chunked takes int, but:
+        #   DeprecationWarning: Chunk size is deprecated #1615
+        # So let's make sure we either put True or None here
+        chunked=True if stream else None,
+        raise_for_status=True,
+    )
     if stream:
         return response
     try:
@@ -193,6 +194,34 @@ async def submit_to_llm_endpoint(
         ) from ex
 
 
+def should_we_giveup(exc: aiohttp.ClientResponseError) -> bool:
+    """
+    From backoff's docs:
+
+    > a function which accepts the exception and returns
+    > a truthy value if the exception should not be retried
+    """
+    LOG.info("Should we give up on retrying error %s", exc)
+    return exc.status < 500
+
+
+def we_give_up(details: backoff._typing.Details):
+    """
+    retries didn't work (or we got a different exc)
+    we give up and raise proper 500 for our API endpoint
+    """
+    LOG.error("Inference error: %s", details["args"])
+    raise HTTPException(500, "Request to the inference API failed")
+
+
+@backoff.on_exception(
+    backoff.expo,
+    aiohttp.ClientResponseError,
+    max_tries=3,
+    giveup=should_we_giveup,
+    raise_on_giveup=False,
+    on_giveup=we_give_up,
+)
 async def submit_text(  # pylint: disable=R0913,R0917
     http: aiohttp.ClientSession,
     text: str,
@@ -265,7 +294,7 @@ async def submit_text_chat_completions(  # pylint: disable=R0913,R0917
     log_probs: int = 1,
     stream: bool = False,
     model: str = "default-model",
-) -> Explanation:
+) -> Union[Explanation, StreamReader]:
     """Submit prompt to OpenAI API /chat/completions endpoint.
     max_tokens: number of tokens to be produces, 0 indicates run until encountering EOS
     log_probs: number of token choices to produce log probs for
@@ -295,10 +324,7 @@ async def submit_text_chat_completions(  # pylint: disable=R0913,R0917
     )
 
     if stream:
-        return Explanation(
-            text=response["choices"][0]["delta"]["content"],
-            logprobs=response["choices"][0]["logprobs"]["content"],
-        )
+        return response
     return Explanation(
         text=response["choices"][0]["message"]["content"],
         logprobs=response["choices"][0]["logprobs"]["content"],
@@ -308,7 +334,7 @@ async def submit_text_chat_completions(  # pylint: disable=R0913,R0917
 @app.post("/analyze", response_model=Response)
 @track_request()
 async def analyze_log(
-    build_log: BuildLog, http: aiohttp.ClientSession = Depends(get_http_session)
+    build_log: BuildLog, 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>"}.
@@ -316,11 +342,12 @@ async def analyze_log(
     Meaning that it must contain appropriate scheme, path and netloc,
     while lacking  result, params or query fields.
     """
-    log_text = await process_url(http, build_log.url)
+    remote_log = RemoteLog(build_log.url, http_session)
+    log_text = await remote_log.process_url()
     log_summary = mine_logs(log_text)
     log_summary = format_snippets(log_summary)
     response = await submit_text(
-        http,
+        http_session,
         PROMPT_CONFIG.prompt_template.format(log_summary),
         model=SERVER_CONFIG.inference.model,
         max_tokens=SERVER_CONFIG.inference.max_tokens,
@@ -340,10 +367,10 @@ async def analyze_log(
     return Response(explanation=response, response_certainty=certainty)
 
 
-@app.post("/analyze/staged", response_model=StagedResponse)
 @track_request()
+@app.post("/analyze/staged", response_model=StagedResponse)
 async def analyze_log_staged(
-    build_log: BuildLog, http: aiohttp.ClientSession = Depends(get_http_session)
+    build_log: BuildLog, 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>"}.
@@ -351,9 +378,10 @@ async def analyze_log_staged(
     Meaning that it must contain appropriate scheme, path and netloc,
     while lacking  result, params or query fields.
     """
-    log_text = await process_url(http, build_log.url)
+    remote_log = RemoteLog(build_log.url, http_session)
+    log_text = await remote_log.process_url()
 
-    return await perform_staged_analysis(http, log_text=log_text)
+    return await perform_staged_analysis(http_session, log_text=log_text)
 
 
 async def perform_staged_analysis(
@@ -413,7 +441,7 @@ async def perform_staged_analysis(
 @app.post("/analyze/stream", response_class=StreamingResponse)
 @track_request()
 async def analyze_log_stream(
-    build_log: BuildLog, http: aiohttp.ClientSession = Depends(get_http_session)
+    build_log: BuildLog, http_session: aiohttp.ClientSession = Depends(get_http_session)
 ):
     """Stream response endpoint for Logdetective.
     Request must be in form {"url":"<YOUR_URL_HERE>"}.
@@ -421,7 +449,8 @@ async def analyze_log_stream(
     Meaning that it must contain appropriate scheme, path and netloc,
     while lacking  result, params or query fields.
     """
-    log_text = await process_url(http, build_log.url)
+    remote_log = RemoteLog(build_log.url, http_session)
+    log_text = await remote_log.process_url()
     log_summary = mine_logs(log_text)
     log_summary = format_snippets(log_summary)
     headers = {"Content-Type": "application/json"}
@@ -429,20 +458,31 @@ async def analyze_log_stream(
     if SERVER_CONFIG.inference.api_token:
         headers["Authorization"] = f"Bearer {SERVER_CONFIG.inference.api_token}"
 
-    stream = await submit_text_chat_completions(
-        http,
-        PROMPT_CONFIG.prompt_template.format(log_summary),
-        stream=True,
-        headers=headers,
-        model=SERVER_CONFIG.inference.model,
-        max_tokens=SERVER_CONFIG.inference.max_tokens,
-    )
+    try:
+        stream = await submit_text_chat_completions(
+            http_session,
+            PROMPT_CONFIG.prompt_template.format(log_summary),
+            stream=True,
+            headers=headers,
+            model=SERVER_CONFIG.inference.model,
+            max_tokens=SERVER_CONFIG.inference.max_tokens,
+        )
+    except aiohttp.ClientResponseError as ex:
+        raise HTTPException(
+            status_code=400,
+            detail="HTTP Error while getting response from inference server "
+            f"[{ex.status}] {ex.message}",
+        ) from ex
 
+    # we need to figure out a better response here, this is how it looks rn:
+    # b'data: {"choices":[{"finish_reason":"stop","index":0,"delta":{}}],
+    #   "created":1744818071,"id":"chatcmpl-c9geTxNcQO7M9wR...
     return StreamingResponse(stream)
 
 
 @app.post("/webhook/gitlab/job_events")
 async def receive_gitlab_job_event_webhook(
+    x_gitlab_instance: Annotated[str | None, Header()],
     job_hook: JobHook,
     background_tasks: BackgroundTasks,
     http: aiohttp.ClientSession = Depends(get_http_session),
@@ -451,17 +491,27 @@ async def receive_gitlab_job_event_webhook(
     https://docs.gitlab.com/user/project/integrations/webhook_events/#job-events
     lists the full specification for the messages sent for job events."""
 
+    try:
+        forge = Forge(x_gitlab_instance)
+    except ValueError:
+        LOG.critical("%s is not a recognized forge. Ignoring.", x_gitlab_instance)
+        return BasicResponse(status_code=400)
+
     # Handle the message in the background so we can return 200 immediately
-    background_tasks.add_task(process_gitlab_job_event, http, job_hook)
+    background_tasks.add_task(process_gitlab_job_event, http, forge, job_hook)
 
     # No return value or body is required for a webhook.
     # 204: No Content
     return BasicResponse(status_code=204)
 
 
-async def process_gitlab_job_event(http: aiohttp.ClientSession, job_hook):
+async def process_gitlab_job_event(
+    http: aiohttp.ClientSession,
+    forge: Forge,
+    job_hook: JobHook,
+):
     """Handle a received job_event webhook from GitLab"""
-    LOG.debug("Received webhook message:\n%s", job_hook)
+    LOG.debug("Received webhook message from %s:\n%s", forge.value, job_hook)
 
     # Look up the project this job belongs to
     project = await asyncio.to_thread(app.gitlab_conn.projects.get, job_hook.project_id)
@@ -502,7 +552,14 @@ async def process_gitlab_job_event(http: aiohttp.ClientSession, job_hook):
 
     # Submit log to Log Detective and await the results.
     log_text = preprocessed_log.read().decode(encoding="utf-8")
+    metrics_id = await add_new_metrics(
+        api_name=EndpointType.ANALYZE_GITLAB_JOB,
+        url=log_url,
+        http_session=http,
+        compressed_log_content=RemoteLog.zip_text(log_text),
+    )
     staged_response = await perform_staged_analysis(http, log_text=log_text)
+    update_metrics(metrics_id, staged_response)
     preprocessed_log.close()
 
     # check if this project is on the opt-in list for posting comments.
@@ -511,7 +568,17 @@ async def process_gitlab_job_event(http: aiohttp.ClientSession, job_hook):
         return
 
     # Add the Log Detective response as a comment to the merge request
-    await comment_on_mr(project, merge_request_iid, job, log_url, staged_response)
+    await comment_on_mr(
+        forge,
+        project,
+        merge_request_iid,
+        job,
+        log_url,
+        staged_response,
+        metrics_id,
+    )
+
+    return staged_response
 
 
 class LogsTooLargeError(RuntimeError):
@@ -520,7 +587,7 @@ class LogsTooLargeError(RuntimeError):
 
 async def retrieve_and_preprocess_koji_logs(
     http: aiohttp.ClientSession, job: gitlab.v4.objects.ProjectJob
-):
+):  # pylint: disable=too-many-branches
     """Download logs from the merge request artifacts
 
     This function will retrieve the build logs and do some minimal
@@ -549,13 +616,16 @@ async def retrieve_and_preprocess_koji_logs(
         if zipinfo.filename.endswith("task_failed.log"):
             # The koji logs store this file in two places: 1) in the
             # directory with the failed architecture and 2) in the parent
-            # directory. We actually want to ignore the one in the parent
-            # directory, since the rest of the information is in the
-            # specific task directory.
+            # directory. Most of the time, we want to ignore the one in the
+            # parent directory, since the rest of the information is in the
+            # specific task directory. However, there are some situations
+            # where non-build failures (such as "Target build already exists")
+            # may be presented only at the top level.
             # The paths look like `kojilogs/noarch-XXXXXX/task_failed.log`
             # or `kojilogs/noarch-XXXXXX/x86_64-XXXXXX/task_failed.log`
             path = PurePath(zipinfo.filename)
             if len(path.parts) <= 3:
+                failed_arches["toplevel"] = path
                 continue
 
             # Extract the architecture from the immediate parent path
@@ -584,30 +654,32 @@ async def retrieve_and_preprocess_koji_logs(
             failed_arches[architecture] = PurePath(path.parent, failure_log_name)
 
     if not failed_arches:
-        # No failed task found?
+        # No failed task found in the sub-tasks.
         raise FileNotFoundError("Could not detect failed architecture.")
 
-    # First check if we only found one failed architecture
-    if len(failed_arches) == 1:
-        failed_arch = list(failed_arches.keys())[0]
-
+    # We only want to handle one arch, so we'll check them in order of
+    # "most to least likely for the maintainer to have access to hardware"
+    # This means: x86_64 > aarch64 > riscv > ppc64le > s390x
+    if "x86_64" in failed_arches:
+        failed_arch = "x86_64"
+    elif "aarch64" in failed_arches:
+        failed_arch = "aarch64"
+    elif "riscv" in failed_arches:
+        failed_arch = "riscv"
+    elif "ppc64le" in failed_arches:
+        failed_arch = "ppc64le"
+    elif "s390x" in failed_arches:
+        failed_arch = "s390x"
+    elif "noarch" in failed_arches:
+        # May have failed during BuildSRPMFromSCM phase
+        failed_arch = "noarch"
+    elif "toplevel" in failed_arches:
+        # Probably a Koji-specific error, not a build error
+        failed_arch = "toplevel"
     else:
-        # We only want to handle one arch, so we'll check them in order of
-        # "most to least likely for the maintainer to have access to hardware"
-        # This means: x86_64 > aarch64 > ppc64le > s390x
-        if "x86_64" in failed_arches:
-            failed_arch = "x86_64"
-        elif "aarch64" in failed_arches:
-            failed_arch = "aarch64"
-        elif "ppc64le" in failed_arches:
-            failed_arch = "ppc64le"
-        elif "s390x" in failed_arches:
-            failed_arch = "s390x"
-        else:
-            # It should be impossible for us to get "noarch" here, since
-            # the only way that should happen is for a single architecture
-            # build.
-            raise FileNotFoundError("No failed architecture detected.")
+        # We have one or more architectures that we don't know about? Just
+        # pick the first alphabetically.
+        failed_arch = sorted(list(failed_arches.keys()))[0]
 
     LOG.debug("Failed architecture: %s", failed_arch)
 
@@ -620,7 +692,10 @@ async def retrieve_and_preprocess_koji_logs(
     return log_url, artifacts_zip.open(log_path)
 
 
-async def check_artifacts_file_size(http: aiohttp.ClientSession, job):
+async def check_artifacts_file_size(
+    http: aiohttp.ClientSession,
+    job: gitlab.v4.objects.ProjectJob,
+):
     """Method to determine if the artifacts are too large to process"""
     # First, make sure that the artifacts are of a reasonable size. The
     # zipped artifact collection will be stored in memory below. The
@@ -651,12 +726,14 @@ async def check_artifacts_file_size(http: aiohttp.ClientSession, job):
     return content_length <= SERVER_CONFIG.gitlab.max_artifact_size
 
 
-async def comment_on_mr(
+async def comment_on_mr(  # pylint: disable=too-many-arguments disable=too-many-positional-arguments
+    forge: Forge,
     project: gitlab.v4.objects.Project,
     merge_request_iid: int,
     job: gitlab.v4.objects.ProjectJob,
     log_url: str,
     response: StagedResponse,
+    metrics_id: int,
 ):
     """Add the Log Detective response as a comment to the merge request"""
     LOG.debug(
@@ -666,6 +743,10 @@ async def comment_on_mr(
         response.explanation.text,
     )
 
+    # First, we'll see if there's an existing comment on this Merge Request
+    # and wrap it in <details></details> to reduce noise.
+    await suppress_latest_comment(forge, project, merge_request_iid)
+
     # Get the formatted short comment.
     short_comment = await generate_mr_comment(job, log_url, response, full=False)
 
@@ -696,6 +777,67 @@ async def comment_on_mr(
     await asyncio.sleep(5)
     await asyncio.to_thread(note.save)
 
+    # Save the new comment to the database
+    try:
+        metrics = AnalyzeRequestMetrics.get_metric_by_id(metrics_id)
+        Comments.create(
+            forge,
+            project.id,
+            merge_request_iid,
+            job.id,
+            discussion.id,
+            metrics,
+        )
+    except sqlalchemy.exc.IntegrityError:
+        # We most likely attempted to save a new comment for the same
+        # build job. This is somewhat common during development when we're
+        # submitting requests manually. It shouldn't really happen in
+        # production.
+        if not SERVER_CONFIG.general.devmode:
+            raise
+
+
+async def suppress_latest_comment(
+    gitlab_instance: str,
+    project: gitlab.v4.objects.Project,
+    merge_request_iid: int,
+) -> None:
+    """Look up the latest comment on this Merge Request, if any, and wrap it
+    in a <details></details> block with a comment indicating that it has been
+    superseded by a new push."""
+
+    # Ask the database for the last known comment for this MR
+    previous_comment = Comments.get_latest_comment(
+        gitlab_instance, project.id, merge_request_iid
+    )
+
+    if previous_comment is None:
+        # No existing comment, so nothing to do.
+        return
+
+    # Retrieve its content from the Gitlab API
+
+    # Look up the merge request
+    merge_request = await asyncio.to_thread(
+        project.mergerequests.get, merge_request_iid
+    )
+
+    # Find the discussion matching the latest comment ID
+    discussion = await asyncio.to_thread(
+        merge_request.discussions.get, previous_comment.comment_id
+    )
+
+    # Get the ID of the first note
+    note_id = discussion.attributes["notes"][0]["id"]
+    note = discussion.notes.get(note_id)
+
+    # Wrap the note in <details>, indicating why.
+    note.body = (
+        "This comment has been superseded by a newer "
+        f"Log Detective analysis.\n<details>\n{note.body}\n</details>"
+    )
+    await asyncio.to_thread(note.save)
+
 
 async def generate_mr_comment(
     job: gitlab.v4.objects.ProjectJob,
@@ -770,61 +912,70 @@ def _multiple_svg_figures_response(figures: list[matplotlib.figure.Figure]):
     return BasicResponse(content=html_content, media_type="text/html")
 
 
-@app.get("/metrics/analyze", response_class=StreamingResponse)
-async def show_analyze_metrics(period_since_now: TimePeriod = Depends(TimePeriod)):
-    """Show statistics for requests and responses in the given period of time
-    for the /analyze API endpoint."""
-    fig_requests = plot.requests_per_time(period_since_now, EndpointType.ANALYZE)
-    fig_responses = plot.average_time_per_responses(
-        period_since_now, EndpointType.ANALYZE
-    )
-    return _multiple_svg_figures_response([fig_requests, fig_responses])
+class MetricRoute(str, Enum):
+    """Routes for metrics"""
 
+    ANALYZE = "analyze"
+    ANALYZE_STAGED = "analyze-staged"
+    ANALYZE_GITLAB_JOB = "analyze-gitlab"
 
-@app.get("/metrics/analyze/requests", response_class=StreamingResponse)
-async def show_analyze_requests(period_since_now: TimePeriod = Depends(TimePeriod)):
-    """Show statistics for the requests received in the given period of time
-    for the /analyze API endpoint."""
-    fig = plot.requests_per_time(period_since_now, EndpointType.ANALYZE)
-    return _svg_figure_response(fig)
 
+class Plot(str, Enum):
+    """Type of served plots"""
 
-@app.get("/metrics/analyze/responses", response_class=StreamingResponse)
-async def show_analyze_responses(period_since_now: TimePeriod = Depends(TimePeriod)):
-    """Show statistics for responses given in the specified period of time
-    for the /analyze API endpoint."""
-    fig = plot.average_time_per_responses(period_since_now, EndpointType.ANALYZE)
-    return _svg_figure_response(fig)
+    REQUESTS = "requests"
+    RESPONSES = "responses"
+    BOTH = ""
 
 
-@app.get("/metrics/analyze/staged", response_class=StreamingResponse)
-async def show_analyze_staged_metrics(
-    period_since_now: TimePeriod = Depends(TimePeriod),
-):
-    """Show statistics for requests and responses in the given period of time
-    for the /analyze/staged API endpoint."""
-    fig_requests = plot.requests_per_time(period_since_now, EndpointType.ANALYZE_STAGED)
-    fig_responses = plot.average_time_per_responses(
-        period_since_now, EndpointType.ANALYZE_STAGED
-    )
-    return _multiple_svg_figures_response([fig_requests, fig_responses])
+ROUTE_TO_ENDPOINT_TYPES = {
+    MetricRoute.ANALYZE: EndpointType.ANALYZE,
+    MetricRoute.ANALYZE_STAGED: EndpointType.ANALYZE_STAGED,
+    MetricRoute.ANALYZE_GITLAB_JOB: EndpointType.ANALYZE_GITLAB_JOB,
+}
 
 
-@app.get("/metrics/analyze/staged/requests", response_class=StreamingResponse)
-async def show_analyze_staged_requests(
+@app.get("/metrics/{route}/", response_class=StreamingResponse)
+@app.get("/metrics/{route}/{plot}", response_class=StreamingResponse)
+async def get_metrics(
+    route: MetricRoute,
+    plot: Plot = Plot.BOTH,
     period_since_now: TimePeriod = Depends(TimePeriod),
 ):
-    """Show statistics for the requests received in the given period of time
-    for the /analyze/staged API endpoint."""
-    fig = plot.requests_per_time(period_since_now, EndpointType.ANALYZE_STAGED)
-    return _svg_figure_response(fig)
-
+    """Get an handler for visualize statistics for the specified endpoint and plot."""
+    endpoint_type = ROUTE_TO_ENDPOINT_TYPES[route]
+
+    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)
+            return _svg_figure_response(fig)
+        if plot == Plot.RESPONSES:
+            fig = plot_engine.average_time_per_responses(
+                period_since_now, endpoint_type
+            )
+            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(
+            period_since_now, endpoint_type
+        )
+        return _multiple_svg_figures_response([fig_requests, fig_responses])
+
+    descriptions = {
+        Plot.REQUESTS: (
+            "Show statistics for the requests received in the given period of time "
+            f"for the /{endpoint_type.value} API endpoint."
+        ),
+        Plot.RESPONSES: (
+            "Show statistics for responses given in the specified period of time "
+            f"for the /{endpoint_type.value} API endpoint."
+        ),
+        Plot.BOTH: (
+            "Show statistics for requests and responses in the given period of time "
+            f"for the /{endpoint_type.value} API endpoint."
+        ),
+    }
+    handler.__doc__ = descriptions[plot]
 
-@app.get("/metrics/analyze/staged/responses", response_class=StreamingResponse)
-async def show_analyze_staged_responses(
-    period_since_now: TimePeriod = Depends(TimePeriod),
-):
-    """Show statistics for responses given in the specified period of time
-    for the /analyze/staged API endpoint."""
-    fig = plot.average_time_per_responses(period_since_now, EndpointType.ANALYZE_STAGED)
-    return _svg_figure_response(fig)
+    return await handler()