logdetective 2.12.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

logdetective/logdetective.py

@@ -41,31 +41,15 @@ def setup_args():
     )
     parser.add_argument(
         "-F",
-        "--filename_suffix",
+        "--filename-suffix",
         help="Suffix of the model file name to be retrieved from Hugging Face.\
                             Makes sense only if the model is specified with Hugging Face name.",
         default="Q4_K.gguf",
     )
     parser.add_argument("-n", "--no-stream", action="store_true")
-    parser.add_argument(
-        "-S",
-        "--summarizer",
-        type=str,
-        default="drain",
-        help="DISABLED: LLM summarization option was removed. \
-                Argument is kept for backward compatibility only.",
-    )
-    parser.add_argument(
-        "-N",
-        "--n_lines",
-        type=int,
-        default=None,
-        help="DISABLED: LLM summarization option was removed. \
-                Argument is kept for backward compatibility only.",
-    )
     parser.add_argument(
         "-C",
-        "--n_clusters",
+        "--n-clusters",
         type=int,
         default=8,
         help="Number of clusters for Drain to organize log chunks into.\
@@ -86,7 +70,7 @@ def setup_args():
         help="Temperature for inference.",
     )
     parser.add_argument(
-        "--skip_snippets",
+        "--skip-snippets",
         type=str,
         default=f"{os.path.dirname(__file__)}/skip_snippets.yml",
         help="Path to patterns for skipping snippets.",
@@ -105,10 +89,6 @@ async def run():  # pylint: disable=too-many-statements,too-many-locals,too-many
         sys.stderr.write("Error: --quiet and --verbose is mutually exclusive.\n")
         sys.exit(2)
 
-    # Emit warning about use of discontinued args
-    if args.n_lines or args.summarizer != "drain":
-        LOG.warning("LLM based summarization was removed. Drain will be used instead.")
-
     # Logging facility setup
     log_level = logging.INFO
     if args.verbose >= 1:

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/database/models/metrics.py

@@ -314,10 +314,13 @@ class AnalyzeRequestMetrics(Base):
                         "time_range"
                     ),
                     (
-                        func.avg(
-                            func.extract(  # pylint: disable=not-callable
-                                "epoch", cls.response_sent_at - cls.request_received_at
-                            )
+                        func.coalesce(
+                            func.avg(
+                                func.extract(  # pylint: disable=not-callable
+                                    "epoch", cls.response_sent_at - cls.request_received_at
+                                )
+                            ),
+                            0
                         )
                     ).label("average_response_seconds"),
                 )

logdetective/server/metric.py

@@ -1,17 +1,24 @@
 import inspect
+from collections import defaultdict
 import datetime
-
-from typing import Optional, Union
+from typing import Optional, Union, Dict
 from functools import wraps
 
 import aiohttp
-
+import numpy
 from starlette.responses import StreamingResponse
-from logdetective.server import models
+
 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.models import (
+    TimePeriod,
+    MetricTimeSeries,
+    StagedResponse,
+    Response,
+    Explanation,
+)
+from logdetective.server.database.models import EndpointType, AnalyzeRequestMetrics, Reactions
 from logdetective.server.exceptions import LogDetectiveMetricsError
 
 
@@ -47,7 +54,7 @@ async def add_new_metrics(
 
 async def update_metrics(
     metrics_id: int,
-    response: Union[models.Response, models.StagedResponse, StreamingResponse],
+    response: Union[Response, StagedResponse, StreamingResponse],
     sent_at: Optional[datetime.datetime] = None,
 ) -> None:
     """Update a database metric entry for a received request,
@@ -71,7 +78,7 @@ async def update_metrics(
     )
     response_length = None
     if hasattr(response, "explanation") and isinstance(
-        response.explanation, models.Explanation
+        response.explanation, Explanation
     ):
         response_length = len(response.explanation.text)
     response_certainty = (
@@ -125,3 +132,189 @@ def track_request(name=None):
         raise NotImplementedError("An async coroutine is needed")
 
     return decorator
+
+
+# TODO: Refactor aggregation to use database operations, instead of timestamp formatting  # pylint: disable=fixme
+class TimeDefinition:
+    """Define time format details, given a time period."""
+
+    def __init__(self, time_period: TimePeriod):
+        self.time_period = time_period
+        self.days_diff = time_period.get_time_period().days
+        if self.time_period.hours:
+            self._time_format = "%Y-%m-%d %H"
+            self._time_delta = datetime.timedelta(hours=1)
+        elif self.time_period.days:
+            self._time_format = "%Y-%m-%d"
+            self._time_delta = datetime.timedelta(days=1)
+        elif self.time_period.weeks:
+            self._time_format = "%Y-%m-%d"
+            self._time_delta = datetime.timedelta(weeks=1)
+
+    @property
+    def time_format(self):
+        # pylint: disable=missing-function-docstring
+        return self._time_format
+
+    @property
+    def time_delta(self):
+        # pylint: disable=missing-function-docstring
+        return self._time_delta
+
+
+def create_time_series_arrays(
+    values_dict: dict[datetime.datetime, int],
+) -> tuple[list, list]:
+    """Create time series arrays from a dictionary of values.
+
+    This function generates two aligned lists:
+    1. An array of timestamps from start_time to end_time
+    2. A corresponding array of values for each timestamp
+
+    Args:
+        values_dict: Dictionary mapping timestamps to their respective values
+    Returns:
+        A tuple containing:
+            - list: Array of timestamps
+            - list: Array of corresponding values
+    """
+
+    timestamps = []
+    values = []
+
+    for timestamp, count in values_dict.items():
+        timestamps.append(timestamp)
+        values.append(count)
+
+    return timestamps, numpy.nan_to_num(values).tolist()
+
+
+async def requests_per_time(
+    period_of_time: TimePeriod,
+    endpoint: EndpointType = EndpointType.ANALYZE,
+    end_time: Optional[datetime.datetime] = None,
+) -> MetricTimeSeries:
+    """
+    Get request counts over a specified time period.
+
+    The time intervals are determined by the provided TimePeriod object, which defines
+    the granularity.
+
+    Args:
+        period_of_time: A TimePeriod object that defines the time period and interval
+                        for the analysis (e.g., hourly, daily, weekly)
+        endpoint: One of the API endpoints
+        end_time: The end time for the analysis period. If None, defaults to the current
+                  UTC time
+
+    Returns:
+        A dictionary with timestamps and associated number of requests
+    """
+    end_time = end_time or datetime.datetime.now(datetime.timezone.utc)
+    start_time = period_of_time.get_period_start_time(end_time)
+    time_def = TimeDefinition(period_of_time)
+    requests_counts = await AnalyzeRequestMetrics.get_requests_in_period(
+        start_time, end_time, time_def.time_format, endpoint
+    )
+    timestamps, counts = create_time_series_arrays(requests_counts)
+
+    return MetricTimeSeries(metric="requests", timestamps=timestamps, values=counts)
+
+
+async def average_time_per_responses(
+    period_of_time: TimePeriod,
+    endpoint: EndpointType = EndpointType.ANALYZE,
+    end_time: Optional[datetime.datetime] = None,
+) -> MetricTimeSeries:
+    """
+    Get average response time and length over a specified time period.
+
+    The time intervals are determined by the provided TimePeriod object, which defines
+    the granularity.
+
+    Args:
+        period_of_time: A TimePeriod object that defines the time period and interval
+                        for the analysis (e.g., hourly, daily, weekly)
+        endpoint: One of the API endpoints
+        end_time: The end time for the analysis period. If None, defaults to the current
+                  UTC time
+
+    Returns:
+        A dictionary of timestamps and average response times
+    """
+    end_time = end_time or datetime.datetime.now(datetime.timezone.utc)
+    start_time = period_of_time.get_period_start_time(end_time)
+    time_def = TimeDefinition(period_of_time)
+    responses_average_time = (
+        await AnalyzeRequestMetrics.get_responses_average_time_in_period(
+            start_time, end_time, time_def.time_format, endpoint
+        )
+    )
+    timestamps, average_time = create_time_series_arrays(
+        responses_average_time,
+    )
+
+    return MetricTimeSeries(metric="avg_response_time", timestamps=timestamps, values=average_time)
+
+
+async def _collect_emoji_data(
+    start_time: datetime.datetime, time_def: TimeDefinition
+) -> Dict[str, Dict[str, list]]:
+    """Collect and organize emoji feedback data
+
+    For each reaction type, a dictionary is created with time stamps
+    as keys, and aggregate counts as values.
+    """
+    reactions = await Reactions.get_since(start_time)
+    reaction_values: defaultdict[str, Dict] = defaultdict(lambda: defaultdict(int))
+
+    for comment_timestamp, reaction in reactions:
+        formatted_timestamp = comment_timestamp.strptime(
+            comment_timestamp.strftime(time_def.time_format), time_def.time_format
+        )
+
+        reaction_values[reaction.reaction_type][formatted_timestamp] += reaction.count
+
+    reaction_time_series = {
+        reaction_type: {
+            "timestamps": reaction_data.keys(),
+            "values": reaction_data.values(),
+        }
+        for reaction_type, reaction_data in reaction_values.items()
+    }
+
+    return reaction_time_series
+
+
+async def emojis_per_time(
+    period_of_time: TimePeriod,
+    end_time: Optional[datetime.datetime] = None,
+) -> list[MetricTimeSeries]:
+    """
+    Retrieve data of emoji feedback over time.
+
+    The time intervals are determined by the provided TimePeriod object, which defines
+    the granularity.
+
+    Args:
+        period_of_time: A TimePeriod object that defines the time period and interval
+                        for the analysis (e.g., hourly, daily, weekly)
+        end_time: The end time for the analysis period. If None, defaults to the current
+                  UTC time
+
+    Returns:
+        A list of `MetricTimeSeries` objects
+    """
+    time_def = TimeDefinition(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 = await _collect_emoji_data(start_time, time_def)
+
+    reaction_values: list[MetricTimeSeries] = []
+    for reaction, time_series in reactions_values_dict.items():
+        reaction_values.append(
+            MetricTimeSeries(
+                metric=f"emoji_{reaction}",
+                timestamps=time_series["timestamps"],
+                values=time_series["values"]))
+    return reaction_values

logdetective/server/models.py

@@ -401,3 +401,15 @@ class TimePeriod(BaseModel):
         if time.tzinfo is None:
             time = time.replace(tzinfo=datetime.timezone.utc)
         return time - self.get_time_period()
+
+
+class MetricTimeSeries(BaseModel):
+    """Recorded values of given metric"""
+    metric: str
+    timestamps: List[datetime.datetime]
+    values: List[float]
+
+
+class MetricResponse(BaseModel):
+    """Requested metrics"""
+    time_series: List[MetricTimeSeries]

logdetective/server/server.py

@@ -5,12 +5,8 @@ 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 (
@@ -50,7 +46,14 @@ from logdetective.server.llm import (
     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.metric import (
+    track_request,
+    add_new_metrics,
+    update_metrics,
+    requests_per_time,
+    average_time_per_responses,
+    emojis_per_time
+)
 from logdetective.server.models import (
     BuildLog,
     Config,
@@ -62,8 +65,8 @@ from logdetective.server.models import (
     StagedResponse,
     TimePeriod,
     ExtractorConfig,
+    MetricResponse,
 )
-from logdetective.server import plot as plot_engine
 from logdetective.server.database.models import (
     EndpointType,
     Forge,
@@ -730,38 +733,6 @@ async def schedule_emoji_collection_for_mr(
     del emoji_lookup[key]
 
 
-def _svg_figure_response(fig: matplotlib.figure.Figure):
-    """Create a response with the given svg figure."""
-    buf = BytesIO()
-    fig.savefig(buf, format="svg", bbox_inches="tight")
-    matplotlib.pyplot.close(fig)
-
-    buf.seek(0)
-    return StreamingResponse(
-        buf,
-        media_type="image/svg+xml",
-        headers={"Content-Disposition": "inline; filename=plot.svg"},
-    )
-
-
-def _multiple_svg_figures_response(figures: list[matplotlib.figure.Figure]):
-    """Create a response with multiple svg figures."""
-    svg_contents = []
-    for i, fig in enumerate(figures):
-        buf = BytesIO()
-        fig.savefig(buf, format="svg", bbox_inches="tight")
-        matplotlib.pyplot.close(fig)
-        buf.seek(0)
-        svg_contents.append(buf.read().decode("utf-8"))
-
-    html_content = "<html><body>\n"
-    for i, svg in enumerate(svg_contents):
-        html_content += f"<div id='figure-{i}'>\n{svg}\n</div>\n"
-    html_content += "</body></html>"
-
-    return BasicResponse(content=html_content, media_type="text/html")
-
-
 class MetricRoute(str, Enum):
     """Routes for metrics"""
 
@@ -770,13 +741,13 @@ class MetricRoute(str, Enum):
     ANALYZE_GITLAB_JOB = "analyze-gitlab"
 
 
-class Plot(str, Enum):
-    """Type of served plots"""
+class MetricType(str, Enum):
+    """Type of metric retrieved"""
 
     REQUESTS = "requests"
     RESPONSES = "responses"
     EMOJIS = "emojis"
-    BOTH = ""
+    ALL = "all"
 
 
 ROUTE_TO_ENDPOINT_TYPES = {
@@ -786,58 +757,57 @@ ROUTE_TO_ENDPOINT_TYPES = {
 }
 
 
-@app.get("/metrics/{route}/", response_class=StreamingResponse)
-@app.get("/metrics/{route}/{plot}", response_class=StreamingResponse)
+@app.get("/metrics/{route}/", response_model=MetricResponse)
+@app.get("/metrics/{route}/{metric_type}", response_model=MetricResponse)
 async def get_metrics(
     route: MetricRoute,
-    plot: Plot = Plot.BOTH,
+    metric_type: MetricType = MetricType.ALL,
     period_since_now: TimePeriod = Depends(TimePeriod),
 ):
-    """Get an handler for visualize statistics for the specified endpoint and plot."""
+    """Get an handler returning statistics for the specified endpoint and metric_type."""
     endpoint_type = ROUTE_TO_ENDPOINT_TYPES[route]
 
-    async def handler():
-        """Show statistics for the specified endpoint and plot."""
-        if plot == Plot.REQUESTS:
-            fig = await plot_engine.requests_per_time(period_since_now, endpoint_type)
-            return _svg_figure_response(fig)
-        if plot == Plot.RESPONSES:
-            fig = await plot_engine.average_time_per_responses(
+    async def handler() -> MetricResponse:
+        """Return statistics for the specified endpoint and metric type."""
+        statistics = []
+        if metric_type == MetricType.ALL:
+            statistics.append(await requests_per_time(
                 period_since_now, endpoint_type
-            )
-            return _svg_figure_response(fig)
-        if plot == Plot.EMOJIS:
-            fig = await plot_engine.emojis_per_time(period_since_now)
-            return _svg_figure_response(fig)
-        # BOTH
-        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 = await plot_engine.emojis_per_time(period_since_now)
-        return _multiple_svg_figures_response([fig_requests, fig_responses, fig_emojis])
+            ))
+            statistics.append(await average_time_per_responses(
+                period_since_now, endpoint_type
+            ))
+            statistics.extend(await emojis_per_time(period_since_now))
+            return MetricResponse(time_series=statistics)
+        if metric_type == MetricType.REQUESTS:
+            statistics.append(await requests_per_time(period_since_now, endpoint_type))
+        elif metric_type == MetricType.RESPONSES:
+            statistics.append(await average_time_per_responses(
+                period_since_now, endpoint_type
+            ))
+        elif metric_type == MetricType.EMOJIS:
+            statistics = await emojis_per_time(period_since_now)
+        return MetricResponse(time_series=statistics)
 
     descriptions = {
-        Plot.REQUESTS: (
-            "Show statistics for the requests received in the given period of time "
+        MetricType.REQUESTS: (
+            "Get 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 "
+        MetricType.RESPONSES: (
+            "Get statistics for responses given in the specified period of time "
             f"for the /{endpoint_type.value} API endpoint."
         ),
-        Plot.EMOJIS: (
-            "Show statistics for emoji feedback in the specified period of time "
+        MetricType.EMOJIS: (
+            "Get statistics for emoji feedback 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 "
+        MetricType.ALL: (
+            "Get statistics for requests and responses in the given period of time "
             f"for the /{endpoint_type.value} API endpoint."
         ),
     }
-    handler.__doc__ = descriptions[plot]
+    handler.__doc__ = descriptions[metric_type]
 
     return await handler()
 

{logdetective-2.12.0.dist-info → logdetective-3.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logdetective
-Version: 2.12.0
+Version: 3.0.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"
@@ -36,7 +36,6 @@ Requires-Dist: flexmock (>=0.12.2,<0.13.0) ; extra == "testing"
 Requires-Dist: huggingface-hub (>=0.23.0,<1.4.0)
 Requires-Dist: koji (>=1.35.0,<2.0.0) ; extra == "server" or extra == "server-testing"
 Requires-Dist: llama-cpp-python (>0.2.56,!=0.2.86,<1.0.0)
-Requires-Dist: matplotlib (>=3.8.4,<4.0.0) ; extra == "server" or extra == "server-testing"
 Requires-Dist: numpy (>=1.26.0)
 Requires-Dist: openai (>=1.82.1,<2.0.0) ; extra == "server" or extra == "server-testing"
 Requires-Dist: pydantic (>=2.8.2,<3.0.0)
@@ -98,11 +97,13 @@ Usage
 To analyze a log file, run the script with the following command line arguments:
 - `file` (required): The path or URL of the log file to be analyzed.
 - `--model` (optional, default: "Mistral-7B-Instruct-v0.3-GGUF"): The path or Hugging space name of the language model for analysis. For models from Hugging Face, write them as `namespace/repo_name`. As we are using LLama.cpp we want this to be in the `gguf` format. If the model is already on your machine it will skip the download.
-- `--filename_suffix` (optional, default "Q4_K.gguf"): You can specify which suffix of the file to use. This option is applied when specifying model using the Hugging Face repository.
-- `--summarizer` DISABLED: LLM summarization option was removed. Argument is kept for backward compatibility only.(optional, default: "drain"): Choose between LLM and Drain template miner as the log summarizer. You can also provide the path to an existing language model file instead of using a URL.
-- `--n_lines` DISABLED: LLM summarization option was removed. Argument is kept for backward compatibility only. (optional, default: 8): The number of lines per chunk for LLM analysis. This only makes sense when you are summarizing with LLM.
-- `--n_clusters` (optional, default 8): Number of clusters for Drain to organize log chunks into. This only makes sense when you are summarizing with Drain.
-- `--skip_snippets` Path to patterns for skipping snippets (in YAML).
+- `--filename-suffix` (optional, default "Q4_K.gguf"): You can specify which suffix of the file to use. This option is applied when specifying model using the Hugging Face repository.
+- `--n-clusters` (optional, default 8): Number of clusters for Drain to organize log chunks into. This only makes sense when you are summarizing with Drain.
+- `--skip-snippets` Path to patterns for skipping snippets (in YAML).
+- `--prompts PROMPTS` Path to prompt configuration file.
+- `--temperature` Temperature for inference.
+- `--skip-snippets` Path to patterns for skipping snippets.
+- `--csgrep` Use csgrep to process the log.
 
 Example usage:
 
@@ -112,9 +113,9 @@ Or if the log file is stored locally:
 
     logdetective ./data/logs.txt
 
-Examples of using different models. Note the use of `--filename_suffix` (or `-F`) option, useful for models that were quantized:
+Examples of using different models. Note the use of `--filename-suffix` (or `-F`) option, useful for models that were quantized:
 
-    logdetective https://example.com/logs.txt --model QuantFactory/Meta-Llama-3-8B-Instruct-GGUF --filename_suffix Q5_K_S.gguf
+    logdetective https://example.com/logs.txt --model QuantFactory/Meta-Llama-3-8B-Instruct-GGUF --filename-suffix Q5_K_S.gguf
     logdetective https://kojipkgs.fedoraproject.org//work/tasks/3367/131313367/build.log --model 'fedora-copr/granite-3.2-8b-instruct-GGUF' -F Q4_K_M.gguf
 
 Example of altered prompts:
@@ -126,7 +127,7 @@ Example of altered prompts:
 
 Note that streaming with some models (notably Meta-Llama-3) is broken and can be worked around by `no-stream` option:
 
-    logdetective https://example.com/logs.txt --model QuantFactory/Meta-Llama-3-8B-Instruct-GGUF --filename_suffix Q5_K_M.gguf --no-stream
+    logdetective https://example.com/logs.txt --model QuantFactory/Meta-Llama-3-8B-Instruct-GGUF --filename-suffix Q5_K_M.gguf --no-stream
 
 Choice of LLM
 -------------

{logdetective-2.12.0.dist-info → logdetective-3.0.0.dist-info}/RECORD

@@ -2,7 +2,7 @@ logdetective/__init__.py,sha256=VqRngDcuFT7JWms8Qc_MsOvajoXVOKPr-S1kqY3Pqhc,59
 logdetective/constants.py,sha256=aCwrkBrDdS_kbNESK-Z-ewg--DSzodV2OMgwEq3UE38,2456
 logdetective/drain3.ini,sha256=ni91eCT1TwTznZwcqWoOVMQcGEnWhEDNCoTPF7cfGfY,1360
 logdetective/extractors.py,sha256=vT-je4NkDgSj9rRtSeLpqBU52gIUnnVgJPHFbVihpCw,5993
-logdetective/logdetective.py,sha256=S0abGrAQH2oi0MRisCV64Sa1UXdQLIfXFBA4tYAYqhM,6896
+logdetective/logdetective.py,sha256=W4yY5PDK0zO_6ObCnLQc6K6xY8zOd8MXJJDaE3LH6Wo,6224
 logdetective/models.py,sha256=uczmQtWFgSp_ZGssngdTM4qzPF1o64dCy0469GoSbjQ,2937
 logdetective/prompts-summary-first.yml,sha256=kmyMFQmqFXpojkz7p3CyCWCPxMpFLpfDdMGisB4YwL0,808
 logdetective/prompts-summary-only.yml,sha256=8U9AMJV8ePW-0CoXOXlQoO92DAJDeutIT8ntSkkm6W0,470
@@ -12,29 +12,28 @@ logdetective/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 logdetective/server/compressors.py,sha256=y4aFYJ_9CbYdKuAI39Kc9GQSdPN8cSJ2c_VAz3T47EE,5249
 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
 logdetective/server/database/models/merge_request_jobs.py,sha256=MxiAVKQIsQMbFylBsmYBmVXYvid-4_5mwwXLfWdp6_w,19965
-logdetective/server/database/models/metrics.py,sha256=4xsUdbtlp5PI1-iJQc5Dd8EPDgVVplD9hJRWeRDn43k,15443
+logdetective/server/database/models/metrics.py,sha256=XpiGrZJ-SuHfePBOeek_WiV-i0p1wjoCBTekSMiZZM0,15559
 logdetective/server/emoji.py,sha256=zSaYtLpSkpRCXpjMWnHR1bYwkmobMJASZ7YNalrd85U,5274
 logdetective/server/exceptions.py,sha256=WN715KLL3ya6FiZ95v70VSbNuVhGuHFzxm2OeEPWQCw,981
 logdetective/server/gitlab.py,sha256=X9JSotUUlG9bOWYbUNKt9KqLUAj6Uocd2KNpfn35ccU,17192
 logdetective/server/koji.py,sha256=LG1pRiKUFvYFRKzgQoUG3pUHfcEwMoaMNjUSMKw_pBA,5640
 logdetective/server/llm.py,sha256=wHMxRbAjI0q3osR5mRDR1kqww_6Pkc7JpF1mh9e6Mg8,10855
-logdetective/server/metric.py,sha256=wLOpgcAch3rwhPA5P2YWUeMNAPsvRGseRjH5HlTb7JM,4529
-logdetective/server/models.py,sha256=iJ-5UgScKKSRL8fRCsM23Z34P3p98LaduwWO-q9rudo,13041
-logdetective/server/plot.py,sha256=8LERgY3vQckaHZV2PZfOrZT8CjCAiji57QCmRW24Rfo,14697
-logdetective/server/server.py,sha256=AM10P72tc_7N0GhH_N7msFhLr7ZGNgIfgTxt2sjasVE,30982
+logdetective/server/metric.py,sha256=8ZhJNbl3eSzZiY0344YXMxLk_MkgjgZB6NcZsPozkkk,11317
+logdetective/server/models.py,sha256=edAHzJoxMh-8v-JzSwHNS5FoV-v1PlmLI-3ZwxfBnf4,13303
+logdetective/server/server.py,sha256=lCIctjXjkaOzto5H_qadYB6RLxAbbHvFOOwYdE_sIgY,29981
 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.12.0.dist-info/METADATA,sha256=q8qwE4AyHr0WfJZwNMbCb3-X0mBQfreXhuNtYxSfOSM,23273
-logdetective-2.12.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-logdetective-2.12.0.dist-info/entry_points.txt,sha256=3K_vXja6PmcA8sNdUi63WdImeiNhVZcEGPTaoJmltfA,63
-logdetective-2.12.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-logdetective-2.12.0.dist-info/RECORD,,
+logdetective-3.0.0.dist-info/METADATA,sha256=nHYpSkE4pz3W557RWhBUwQMh3i52KTlx7_rDXoL3wzQ,22874
+logdetective-3.0.0.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
+logdetective-3.0.0.dist-info/entry_points.txt,sha256=3K_vXja6PmcA8sNdUi63WdImeiNhVZcEGPTaoJmltfA,63
+logdetective-3.0.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+logdetective-3.0.0.dist-info/RECORD,,

{logdetective-2.12.0.dist-info → logdetective-3.0.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

logdetective/server/plot.py

@@ -1,432 +0,0 @@
-import datetime
-from typing import Optional, Union, Dict
-
-import numpy
-from numpy.typing import ArrayLike
-from matplotlib import dates, colormaps, axes, pyplot, figure
-
-from logdetective.server.models import TimePeriod
-from logdetective.server.database.models import (
-    AnalyzeRequestMetrics,
-    EndpointType,
-    Reactions,
-)
-
-
-class Definition:
-    """Define plot details, given a time period."""
-
-    def __init__(self, time_period: TimePeriod):
-        self.time_period = time_period
-        self.days_diff = time_period.get_time_period().days
-        if self.time_period.hours:
-            self._freq = "H"
-            self._time_format = "%Y-%m-%d %H"
-            self._locator = dates.HourLocator(interval=2)
-            self._time_unit = "hour"
-            self._time_delta = datetime.timedelta(hours=1)
-        elif self.time_period.days:
-            self._freq = "D"
-            self._time_format = "%Y-%m-%d"
-            self._locator = dates.DayLocator(interval=1)
-            self._time_unit = "day"
-            self._time_delta = datetime.timedelta(days=1)
-        elif self.time_period.weeks:
-            self._freq = "W"
-            self._time_format = "%Y-%m-%d"
-            self._locator = dates.WeekdayLocator(interval=1)
-            self._time_unit = "week"
-            self._time_delta = datetime.timedelta(weeks=1)
-
-    @property
-    def freq(self):
-        # pylint: disable=missing-function-docstring
-        return self._freq
-
-    @property
-    def time_format(self):
-        # pylint: disable=missing-function-docstring
-        return self._time_format
-
-    @property
-    def locator(self):
-        # pylint: disable=missing-function-docstring
-        return self._locator
-
-    @property
-    def time_unit(self):
-        # pylint: disable=missing-function-docstring
-        return self._time_unit
-
-    @property
-    def time_delta(self):
-        # pylint: disable=missing-function-docstring
-        return self._time_delta
-
-
-def create_time_series_arrays(
-    values_dict: dict[datetime.datetime, int],
-    plot_def: Definition,
-    start_time: datetime.datetime,
-    end_time: datetime.datetime,
-    value_type: Optional[Union[type[int], type[float]]] = int,
-) -> tuple[numpy.ndarray, numpy.ndarray]:
-    """Create time series arrays from a dictionary of values.
-
-    This function generates two aligned numpy arrays:
-    1. An array of timestamps from start_time to end_time
-    2. A corresponding array of valuesfor each timestamp
-
-    The timestamps are truncated to the precision specified by time_format.
-    If a timestamp in values_dict matches a generated timestamp, its values is used;
-    otherwise, the value defaults to zero.
-
-    Args:
-        values_dict: Dictionary mapping timestamps to their respective values
-        start_time: The starting timestamp of the time series
-        end_time: The ending timestamp of the time series
-        time_delta: The time interval between consecutive timestamps
-        time_format: String format for datetime truncation (e.g., '%Y-%m-%d %H:%M')
-
-    Returns:
-        A tuple containing:
-            - numpy.ndarray: Array of timestamps
-            - numpy.ndarray: Array of corresponding values
-    """
-    num_intervals = int((end_time - start_time) / plot_def.time_delta) + 1
-
-    timestamps = numpy.array(
-        [
-            datetime.datetime.strptime(
-                (start_time + i * plot_def.time_delta).strftime(
-                    format=plot_def.time_format
-                ),
-                plot_def.time_format,
-            )
-            for i in range(num_intervals)
-        ]
-    )
-    values = numpy.zeros(num_intervals, dtype=value_type)
-
-    timestamp_to_index = {timestamp: i for i, timestamp in enumerate(timestamps)}
-
-    for timestamp, count in values_dict.items():
-        if timestamp in timestamp_to_index:
-            values[timestamp_to_index[timestamp]] = count
-
-    return timestamps, values
-
-
-def _add_bar_chart(
-    ax: axes.Axes,
-    plot_def: Definition,
-    timestamps: ArrayLike,
-    values: ArrayLike,
-    label: str,
-) -> None:
-    """Add a blue bar chart"""
-    bar_width = (
-        0.8 * plot_def.time_delta.total_seconds() / 86400
-    )  # Convert to days for matplotlib
-    ax.bar(
-        timestamps,
-        values,
-        width=bar_width,
-        alpha=0.7,
-        color="skyblue",
-        label=label,
-    )
-    ax.set_xlabel("Time")
-    ax.set_ylabel(label, color="blue")
-    ax.tick_params(axis="y", labelcolor="blue")
-
-    ax.xaxis.set_major_formatter(dates.DateFormatter(plot_def.time_format))
-    ax.xaxis.set_major_locator(plot_def.locator)
-
-    pyplot.xticks(rotation=45)
-
-    ax.grid(True, alpha=0.3)
-
-
-def _add_line_chart(  # pylint: disable=too-many-arguments disable=too-many-positional-arguments
-    ax: axes.Axes,
-    timestamps: ArrayLike,
-    values: ArrayLike,
-    label: str,
-    color: str = "red",
-    set_label: bool = True,
-):
-    """Add a red line chart"""
-    ax.plot(timestamps, values, color=color, linestyle="-", linewidth=2, label=label)
-    if set_label:
-        ax.set_ylabel(label, color=color)
-        ax.tick_params(axis="y", labelcolor=color)
-
-
-async def requests_per_time(
-    period_of_time: TimePeriod,
-    endpoint: EndpointType = EndpointType.ANALYZE,
-    end_time: Optional[datetime.datetime] = None,
-) -> figure.Figure:
-    """
-    Generate a visualization of request counts over a specified time period.
-
-    This function creates a dual-axis plot showing:
-    1. A bar chart of request counts per time interval
-    2. A line chart showing the cumulative request count
-
-    The time intervals are determined by the provided TimePeriod object, which defines
-    the granularity and formatting of the time axis.
-
-    Args:
-        period_of_time: A TimePeriod object that defines the time period and interval
-                        for the analysis (e.g., hourly, daily, weekly)
-        endpoint: One of the API endpoints
-        end_time: The end time for the analysis period. If None, defaults to the current
-                  UTC time
-
-    Returns:
-        A matplotlib Figure object containing the generated visualization
-    """
-    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 = await AnalyzeRequestMetrics.get_requests_in_period(
-        start_time, end_time, plot_def.time_format, endpoint
-    )
-    timestamps, counts = create_time_series_arrays(
-        requests_counts, plot_def, start_time, end_time
-    )
-
-    fig, ax1 = pyplot.subplots(figsize=(12, 6))
-    _add_bar_chart(ax1, plot_def, timestamps, counts, "Requests")
-
-    ax2 = ax1.twinx()
-    _add_line_chart(ax2, timestamps, numpy.cumsum(counts), "Cumulative Requests")
-
-    pyplot.title(
-        f"Requests received for API {endpoint} ({start_time.strftime(plot_def.time_format)} "
-        f"to {end_time.strftime(plot_def.time_format)})"
-    )
-
-    lines1, labels1 = ax1.get_legend_handles_labels()
-    lines2, labels2 = ax2.get_legend_handles_labels()
-    ax1.legend(lines1 + lines2, labels1 + labels2, loc="center")
-
-    pyplot.tight_layout()
-
-    return fig
-
-
-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,
-) -> figure.Figure:
-    """
-    Generate a visualization of average response time and length over a specified time period.
-
-    This function creates a dual-axis plot showing:
-    1. A bar chart of average response time per time interval
-    1. A line chart of average response length per time interval
-
-    The time intervals are determined by the provided TimePeriod object, which defines
-    the granularity and formatting of the time axis.
-
-    Args:
-        period_of_time: A TimePeriod object that defines the time period and interval
-                        for the analysis (e.g., hourly, daily, weekly)
-        endpoint: One of the API endpoints
-        end_time: The end time for the analysis period. If None, defaults to the current
-                  UTC time
-
-    Returns:
-        A matplotlib Figure object containing the generated visualization
-    """
-    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 = (
-        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,
-        plot_def,
-        start_time,
-        end_time,
-        float,
-    )
-
-    fig, ax1 = pyplot.subplots(figsize=(12, 6))
-    _add_bar_chart(
-        ax1, plot_def, timestamps, average_time, "average response time (seconds)"
-    )
-
-    responses_average_length = (
-        await AnalyzeRequestMetrics.get_responses_average_length_in_period(
-            start_time, end_time, plot_def.time_format, endpoint
-        )
-    )
-    timestamps, average_length = create_time_series_arrays(
-        responses_average_length,
-        plot_def,
-        start_time,
-        end_time,
-        float,
-    )
-
-    ax2 = ax1.twinx()
-    _add_line_chart(ax2, timestamps, average_length, "average response length (chars)")
-
-    pyplot.title(
-        f"average response time for API {endpoint} ({start_time.strftime(plot_def.time_format)} "
-        f"to {end_time.strftime(plot_def.time_format)})"
-    )
-
-    lines1, labels1 = ax1.get_legend_handles_labels()
-    lines2, labels2 = ax2.get_legend_handles_labels()
-    ax1.legend(lines1 + lines2, labels1 + labels2, loc="center")
-
-    pyplot.tight_layout()
-
-    return fig
-
-
-async def _collect_emoji_data(
-    start_time: datetime.datetime, plot_def: Definition
-) -> Dict[str, Dict[datetime.datetime, int]]:
-    """Collect and organize emoji feedback data
-
-    Counts all emojis given to logdetective comments created since start_time.
-    Collect counts in time accordingly to the plot definition.
-    """
-    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(
-            comment_created_at.strftime(plot_def.time_format), plot_def.time_format
-        )
-        if reaction.reaction_type in reactions_values_dict:
-            reaction_values_dict = reactions_values_dict[reaction.reaction_type]
-            if comment_created_at_formatted in reaction_values_dict:
-                reaction_values_dict[comment_created_at_formatted] += reaction.count
-            else:
-                reaction_values_dict[comment_created_at_formatted] = reaction.count
-        else:
-            reaction_values_dict = {comment_created_at_formatted: reaction.count}
-            reactions_values_dict.update({reaction.reaction_type: reaction_values_dict})
-
-    return reactions_values_dict
-
-
-def _plot_emoji_data(  # pylint: disable=too-many-locals
-    ax: axes.Axes,
-    reactions_values_dict: Dict[str, Dict[datetime.datetime, int]],
-    plot_def: Definition,
-    start_time: datetime.datetime,
-    end_time: datetime.datetime,
-):
-    """Plot each emoji's data on its own axis."""
-    emoji_lines = {}
-    emoji_labels = {}
-
-    # Find global min and max y values to set consistent scale
-    all_counts = []
-    for emoji, dict_counts in reactions_values_dict.items():
-        timestamps, counts = create_time_series_arrays(
-            dict_counts, plot_def, start_time, end_time
-        )
-        all_counts.extend(counts)
-
-    colors = [
-        colormaps["viridis"](i)
-        for i in numpy.linspace(0, 1, len(reactions_values_dict))
-    ]
-
-    first_emoji = True
-    for i, (emoji, dict_counts) in enumerate(reactions_values_dict.items()):
-        timestamps, counts = create_time_series_arrays(
-            dict_counts, plot_def, start_time, end_time
-        )
-
-        if first_emoji:
-            current_ax = ax
-            first_emoji = False
-        else:
-            current_ax = ax.twinx()
-            current_ax.spines["right"].set_position(("outward", 60 * (i - 1)))
-
-        _add_line_chart(current_ax, timestamps, counts, f"{emoji}", colors[i], False)
-        emoji_lines[emoji], emoji_labels[emoji] = current_ax.get_legend_handles_labels()
-
-        # Set the same y-limits for all axes
-        current_ax.set_ylim(0, max(all_counts) * 1.1)
-
-        # Only show y-ticks on the first axis to avoid clutter
-        if 0 < i < len(reactions_values_dict):
-            current_ax.set_yticks([])
-
-    return emoji_lines, emoji_labels
-
-
-async def emojis_per_time(
-    period_of_time: TimePeriod,
-    end_time: Optional[datetime.datetime] = None,
-) -> figure.Figure:
-    """
-    Generate a visualization of overall emoji feedback
-    over a specified time period.
-
-    This function creates a multiple-axis plot showing
-    a line chart for every found emoji
-
-    The time intervals are determined by the provided TimePeriod object, which defines
-    the granularity and formatting of the time axis.
-
-    Args:
-        period_of_time: A TimePeriod object that defines the time period and interval
-                        for the analysis (e.g., hourly, daily, weekly)
-        end_time: The end time for the analysis period. If None, defaults to the current
-                  UTC time
-
-    Returns:
-        A matplotlib Figure object containing the generated visualization
-    """
-    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 = await _collect_emoji_data(start_time, plot_def)
-
-    fig, ax = pyplot.subplots(figsize=(12, 6))
-
-    emoji_lines, emoji_labels = _plot_emoji_data(
-        ax, reactions_values_dict, plot_def, start_time, end_time
-    )
-
-    pyplot.title(
-        f"Emoji feedback ({start_time.strftime(plot_def.time_format)} "
-        f"to {end_time.strftime(plot_def.time_format)})"
-    )
-
-    all_lines = []
-    for lines in emoji_lines.values():
-        all_lines.extend(lines)
-    all_labels = []
-    for labels in emoji_labels.values():
-        all_labels.extend(labels)
-
-    ax.legend(all_lines, all_labels, loc="upper left")
-    ax.set_xlabel("Time")
-    ax.set_ylabel("Count")
-
-    # Format x-axis
-    ax.xaxis.set_major_formatter(dates.DateFormatter(plot_def.time_format))
-    ax.xaxis.set_major_locator(plot_def.locator)
-    ax.tick_params(axis="x", labelrotation=45)
-    ax.grid(True, alpha=0.3)
-
-    pyplot.tight_layout()
-
-    return fig