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

logdetective/server/metric.py

@@ -1,6 +1,5 @@
 import io
 import inspect
-import logging
 import datetime
 
 from typing import Union
@@ -9,12 +8,11 @@ from functools import wraps
 import aiohttp
 
 from starlette.responses import StreamingResponse
-from logdetective.server.database.models import EndpointType, AnalyzeRequestMetrics
-from logdetective.server.remote_log import RemoteLog
 from logdetective.server import models
-from logdetective.server.compressors import LLMResponseCompressor
-
-LOG = logging.getLogger("logdetective")
+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
 
 
 async def add_new_metrics(
@@ -31,7 +29,9 @@ async def add_new_metrics(
     and the log (in a zip format) for which analysis is requested.
     """
     remote_log = RemoteLog(url, http_session)
-    compressed_log_content = compressed_log_content or await remote_log.zip_content()
+    compressed_log_content = (
+        compressed_log_content or await RemoteLogCompressor(remote_log).zip_content()
+    )
     return AnalyzeRequestMetrics.create(
         endpoint=EndpointType(api_name),
         compressed_log=compressed_log_content,
@@ -58,7 +58,8 @@ def update_metrics(
         compressed_response = None
         LOG.warning(
             "Given response can not be serialized "
-            "and saved in db (probably a StreamingResponse): %s.", e
+            "and saved in db (probably a StreamingResponse): %s.",
+            e,
         )
 
     response_sent_at = (
@@ -83,7 +84,24 @@ def update_metrics(
 
 def track_request(name=None):
     """
-    Decorator to track requests metrics
+    Decorator to track requests/responses metrics
+
+    On entering the decorated function, it registers the time for the request
+    and saves the passed log content.
+    On exiting the decorated function, it registers the time for the response
+    and saves the generated response.
+
+    Use it to decorate server endpoints that generate a llm response
+    as in the following example:
+
+    >>> @app.post("/analyze", response_model=Response)
+    >>> @track_request()
+    >>> async def analyze_log(build_log)
+    >>>     pass
+
+    Warning: the decorators' order is important!
+    The function returned by the *track_request* decorator is the
+    server API function we want to be called by FastAPI.
     """
 
     def decorator(f):

logdetective/server/models.py

@@ -9,7 +9,15 @@ from pydantic import (
     NonNegativeFloat,
     HttpUrl,
 )
-from logdetective.constants import DEFAULT_TEMPERATURE
+
+from aiolimiter import AsyncLimiter
+from gitlab import Gitlab
+
+from logdetective.constants import (
+    DEFAULT_TEMPERATURE,
+    LLM_DEFAULT_MAX_QUEUE_SIZE,
+    LLM_DEFAULT_REQUESTS_PER_MINUTE,
+)
 
 
 class BuildLog(BaseModel):
@@ -46,6 +54,33 @@ class JobHook(BaseModel):
     project_id: int
 
 
+class EmojiMergeRequest(BaseModel):
+    """Model of the 'merge_request' subsection of Emoji webhook messages.
+    This model implements only the fields that we care about. The webhook
+    sends many more fields that we will ignore."""
+
+    # The identifier of the target project
+    target_project_id: int
+
+    # The internal identifier (relative to the target project)
+    iid: int
+
+
+class EmojiHook(BaseModel):
+    """Model of Job Hook events sent from GitLab.
+    Full details of the specification are available at
+    https://docs.gitlab.com/user/project/integrations/webhook_events/#job-events
+    This model implements only the fields that we care about. The webhook
+    sends many more fields that we will ignore."""
+
+    # The kind of webhook message. We are only interested in 'emoji' messages
+    # which represents awarding or revoking emoji reactions on notes.
+    object_kind: str = Field(pattern=r"^emoji$")
+
+    # Information about the merge request this emoji applies to, if any.
+    merge_request: EmojiMergeRequest = Field(default=None)
+
+
 class Explanation(BaseModel):
     """Model of snippet or general log explanation from Log Detective"""
 
@@ -92,7 +127,7 @@ class StagedResponse(Response):
     snippets: List[AnalyzedSnippet]
 
 
-class InferenceConfig(BaseModel):
+class InferenceConfig(BaseModel):  # pylint: disable=too-many-instance-attributes
     """Model for inference configuration of logdetective server."""
 
     max_tokens: int = -1
@@ -104,6 +139,9 @@ class InferenceConfig(BaseModel):
     api_token: str = ""
     model: str = ""
     temperature: NonNegativeFloat = DEFAULT_TEMPERATURE
+    max_queue_size: int = LLM_DEFAULT_MAX_QUEUE_SIZE
+    request_period: float = 60.0 / LLM_DEFAULT_REQUESTS_PER_MINUTE
+    _limiter: AsyncLimiter = AsyncLimiter(LLM_DEFAULT_REQUESTS_PER_MINUTE)
 
     def __init__(self, data: Optional[dict] = None):
         super().__init__()
@@ -117,6 +155,16 @@ class InferenceConfig(BaseModel):
         self.api_token = data.get("api_token", "")
         self.model = data.get("model", "default-model")
         self.temperature = data.get("temperature", DEFAULT_TEMPERATURE)
+        self.max_queue_size = data.get("max_queue_size", LLM_DEFAULT_MAX_QUEUE_SIZE)
+
+        self._requests_per_minute = data.get(
+            "requests_per_minute", LLM_DEFAULT_REQUESTS_PER_MINUTE
+        )
+        self._limiter = AsyncLimiter(self._requests_per_minute)
+
+    def get_limiter(self):
+        """Return the limiter object so it can be used as a context manager"""
+        return self._limiter
 
 
 class ExtractorConfig(BaseModel):
@@ -136,26 +184,50 @@ class ExtractorConfig(BaseModel):
         self.verbose = data.get("verbose", False)
 
 
-class GitLabConfig(BaseModel):
+class GitLabInstanceConfig(BaseModel):
     """Model for GitLab configuration of logdetective server."""
 
+    name: str = None
     url: str = None
     api_url: str = None
     api_token: str = None
+    _conn: Gitlab = None
 
     # Maximum size of artifacts.zip in MiB. (default: 300 MiB)
     max_artifact_size: int = 300
 
-    def __init__(self, data: Optional[dict] = None):
+    def __init__(self, name: str, data: Optional[dict] = None):
         super().__init__()
         if data is None:
             return
 
+        self.name = name
         self.url = data.get("url", "https://gitlab.com")
         self.api_url = f"{self.url}/api/v4"
         self.api_token = data.get("api_token", None)
         self.max_artifact_size = int(data.get("max_artifact_size")) * 1024 * 1024
 
+        self._conn = Gitlab(url=self.url, private_token=self.api_token)
+
+    def get_connection(self):
+        """Get the Gitlab connection object"""
+        return self._conn
+
+
+class GitLabConfig(BaseModel):
+    """Model for GitLab configuration of logdetective server."""
+
+    instances: Dict[str, GitLabInstanceConfig] = {}
+
+    def __init__(self, data: Optional[dict] = None):
+        super().__init__()
+        if data is None:
+            return
+
+        for instance_name, instance_data in data.items():
+            instance = GitLabInstanceConfig(instance_name, instance_data)
+            self.instances[instance.url] = instance
+
 
 class LogConfig(BaseModel):
     """Logging configuration"""
@@ -232,7 +304,7 @@ 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 isinstance(data, dict):
             how_many_fields = sum(
                 1
@@ -284,6 +356,6 @@ class TimePeriod(BaseModel):
             datetime.datetime: The start time of the period.
         """
         time = end_time or datetime.datetime.now(datetime.timezone.utc)
-        if end_time.tzinfo is None:
+        if time.tzinfo is None:
             end_time = end_time.replace(tzinfo=datetime.timezone.utc)
         return time - self.get_time_period()

logdetective/server/plot.py

@@ -1,13 +1,18 @@
 import datetime
-from typing import Optional, Union
+from typing import Optional, Union, Dict
 
 import numpy
 import matplotlib
 import matplotlib.figure
 import matplotlib.pyplot
 
+from matplotlib.pyplot import cm
 from logdetective.server import models
-from logdetective.server.database.models import AnalyzeRequestMetrics, EndpointType
+from logdetective.server.database.models import (
+    AnalyzeRequestMetrics,
+    EndpointType,
+    Reactions,
+)
 
 
 class Definition:
@@ -145,13 +150,19 @@ def _add_bar_chart(
     ax.grid(True, alpha=0.3)
 
 
-def _add_line_chart(
-    ax: matplotlib.figure.Axes, timestamps: numpy.array, values: numpy.array, label: str
-) -> None:
+def _add_line_chart(  # pylint: disable=too-many-arguments disable=too-many-positional-arguments
+    ax: matplotlib.figure.Axes,
+    timestamps: numpy.array,
+    values: numpy.array,
+    label: str,
+    color: str = "red",
+    set_label: bool = True,
+):
     """Add a red line chart"""
-    ax.plot(timestamps, values, "r-", linewidth=2, label=label)
-    ax.set_ylabel(label, color="red")
-    ax.tick_params(axis="y", labelcolor="red")
+    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)
 
 
 def requests_per_time(
@@ -249,7 +260,9 @@ def average_time_per_responses(  # pylint: disable=too-many-locals
     )
 
     fig, ax1 = matplotlib.pyplot.subplots(figsize=(12, 6))
-    _add_bar_chart(ax1, plot_def, timestamps, average_time, "average response time (seconds)")
+    _add_bar_chart(
+        ax1, plot_def, timestamps, average_time, "average response time (seconds)"
+    )
 
     responses_average_length = (
         AnalyzeRequestMetrics.get_responses_average_length_in_period(
@@ -279,3 +292,138 @@ def average_time_per_responses(  # pylint: disable=too-many-locals
     matplotlib.pyplot.tight_layout()
 
     return fig
+
+
+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 = 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: matplotlib.figure.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 = [cm.viridis(i) for i in numpy.linspace(0, 1, len(reactions_values_dict))]    # pylint: disable=no-member
+
+    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
+
+
+def emojis_per_time(
+    period_of_time: models.TimePeriod,
+    end_time: Optional[datetime.datetime] = None,
+) -> matplotlib.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 = _collect_emoji_data(start_time, plot_def)
+
+    fig, ax = matplotlib.pyplot.subplots(figsize=(12, 6))
+
+    emoji_lines, emoji_labels = _plot_emoji_data(
+        ax, reactions_values_dict, plot_def, start_time, end_time
+    )
+
+    matplotlib.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(matplotlib.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)
+
+    matplotlib.pyplot.tight_layout()
+
+    return fig