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

logdetective/constants.py

@@ -16,6 +16,8 @@ Snippets are delimited with '================'.
 
 Finally, drawing on information from all snippets, provide complete explanation of the issue and recommend solution.
 
+Explanation of the issue, and recommended solution, should take handful of sentences.
+
 Snippets:
 
 {}
@@ -38,6 +40,8 @@ Answer:
 SNIPPET_PROMPT_TEMPLATE = """
 Analyse following RPM build log snippet. Describe contents accurately, without speculation or suggestions for resolution.
 
+Your analysis must be as concise as possible, while keeping relevant information intact.
+
 Snippet:
 
 {}
@@ -55,6 +59,8 @@ Snippets are delimited with '================'.
 
 Drawing on information from all snippets, provide complete explanation of the issue and recommend solution.
 
+Explanation of the issue, and recommended solution, should take handful of sentences.
+
 Snippets:
 
 {}
@@ -64,3 +70,5 @@ Analysis:
 """
 
 SNIPPET_DELIMITER = "================"
+
+DEFAULT_TEMPERATURE = 0.8

logdetective/logdetective.py

@@ -1,9 +1,12 @@
 import argparse
+import asyncio
 import logging
 import sys
 import os
 
-from logdetective.constants import DEFAULT_ADVISOR
+import aiohttp
+
+from logdetective.constants import DEFAULT_ADVISOR, DEFAULT_TEMPERATURE
 from logdetective.utils import (
     process_log,
     initialize_model,
@@ -73,10 +76,16 @@ def setup_args():
         default=f"{os.path.dirname(__file__)}/prompts.yml",
         help="Path to prompt configuration file."
     )
+    parser.add_argument(
+        "--temperature",
+        type=float,
+        default=DEFAULT_TEMPERATURE,
+        help="Temperature for inference."
+    )
     return parser.parse_args()
 
 
-def main():  # pylint: disable=too-many-statements,too-many-locals
+async def run():  # pylint: disable=too-many-statements,too-many-locals
     """Main execution function."""
     args = setup_args()
 
@@ -122,13 +131,14 @@ def main():  # pylint: disable=too-many-statements,too-many-locals
 
     LOG.info("Getting summary")
 
-    try:
-        log = retrieve_log_content(args.file)
-    except ValueError as e:
-        # file does not exists
-        LOG.error(e)
-        sys.exit(4)
-    log_summary = extractor(log)
+    async with aiohttp.ClientSession() as http:
+        try:
+            log = await retrieve_log_content(http, args.file)
+        except ValueError as e:
+            # file does not exist
+            LOG.error(e)
+            sys.exit(4)
+        log_summary = extractor(log)
 
     ratio = len(log_summary) / len(log.split("\n"))
 
@@ -147,6 +157,7 @@ def main():  # pylint: disable=too-many-statements,too-many-locals
         model,
         stream,
         prompt_template=prompts_configuration.prompt_template,
+        temperature=args.temperature,
     )
     probs = []
     print("Explanation:")
@@ -175,5 +186,10 @@ def main():  # pylint: disable=too-many-statements,too-many-locals
     print(f"\nResponse certainty: {certainty:.2f}%\n")
 
 
+def main():
+    """ Evaluate logdetective program and wait for it to finish """
+    asyncio.run(run())
+
+
 if __name__ == "__main__":
     main()

logdetective/prompts.yml

@@ -13,6 +13,8 @@ prompt_template: |
 
   Finally, drawing on information from all snippets, provide complete explanation of the issue and recommend solution.
 
+  Explanation of the issue, and recommended solution, should take handful of sentences.
+
   Snippets:
 
   {}
@@ -33,6 +35,8 @@ summarization_prompt_template: |
 snippet_prompt_template: |
   Analyse following RPM build log snippet. Describe contents accurately, without speculation or suggestions for resolution.
 
+  Your analysis must be as concise as possible, while keeping relevant information intact.
+
   Snippet:
 
   {}
@@ -48,6 +52,8 @@ prompt_template_staged: |
 
   Drawing on information from all snippets, provide complete explanation of the issue and recommend solution.
 
+  Explanation of the issue, and recommended solution, should take handful of sentences.
+
   Snippets:
 
   {}

logdetective/server/database/models.py

@@ -97,17 +97,35 @@ class AnalyzeRequestMetrics(Base):
             metrics.response_certainty = response_certainty
             session.add(metrics)
 
+    @classmethod
+    def get_postgres_time_format(cls, time_format):
+        """Map python time format in the PostgreSQL format."""
+        if time_format == "%Y-%m-%d":
+            pgsql_time_format = "YYYY-MM-DD"
+        else:
+            pgsql_time_format = "YYYY-MM-DD HH24"
+        return pgsql_time_format
+
+    @classmethod
+    def get_dictionary_with_datetime_keys(
+        cls, time_format: str, values_dict: dict[str, any]
+    ) -> dict[datetime.datetime, any]:
+        """Convert from a dictionary with str keys to a dictionary with datetime keys"""
+        new_dict = {
+            datetime.datetime.strptime(r[0], time_format): r[1] for r in values_dict
+        }
+        return new_dict
+
     @classmethod
     def _get_requests_by_time_for_postgres(
         cls, start_time, end_time, time_format, endpoint
     ):
-        """func.to_char is PostgreSQL specific.
+        """Get total requests number in time period.
+
+        func.to_char is PostgreSQL specific.
         Let's unit tests replace this function with the SQLite version.
         """
-        if time_format == "%Y-%m-%d":
-            pgsql_time_format = "YYYY-MM-DD"
-        else:
-            pgsql_time_format = "YYYY-MM-DD HH24"
+        pgsql_time_format = cls.get_postgres_time_format(time_format)
 
         requests_by_time_format = (
             select(
@@ -123,10 +141,12 @@ class AnalyzeRequestMetrics(Base):
         return requests_by_time_format
 
     @classmethod
-    def _get_requests_by_time_for_sqllite(
+    def _get_requests_by_time_for_sqlite(
         cls, start_time, end_time, time_format, endpoint
     ):
-        """func.strftime is SQLite specific.
+        """Get total requests number in time period.
+
+        func.strftime is SQLite specific.
         Use this function in unit test using flexmock:
 
         flexmock(AnalyzeRequestMetrics).should_receive("_get_requests_by_time_for_postgres")
@@ -178,9 +198,193 @@ class AnalyzeRequestMetrics(Base):
             counts = session.execute(count_requests_by_time_format)
             results = counts.fetchall()
 
-            # Convert results to a dictionary with proper datetime keys
-            counts_dict = {
-                datetime.datetime.strptime(r[0], time_format): r[1] for r in results
-            }
+            return cls.get_dictionary_with_datetime_keys(time_format, results)
+
+    @classmethod
+    def _get_average_responses_times_for_postgres(
+        cls, start_time, end_time, time_format, endpoint
+    ):
+        """Get average responses time.
+
+        func.to_char is PostgreSQL specific.
+        Let's unit tests replace this function with the SQLite version.
+        """
+        with transaction(commit=False) as session:
+            pgsql_time_format = cls.get_postgres_time_format(time_format)
+
+            average_responses_times = (
+                select(
+                    func.to_char(cls.request_received_at, pgsql_time_format).label(
+                        "time_range"
+                    ),
+                    (
+                        func.avg(
+                            func.extract(  # pylint: disable=not-callable
+                                "epoch", cls.response_sent_at - cls.request_received_at
+                            )
+                        )
+                    ).label("average_response_seconds"),
+                )
+                .filter(cls.request_received_at.between(start_time, end_time))
+                .filter(cls.endpoint == endpoint)
+                .group_by("time_range")
+                .order_by("time_range")
+            )
+
+            results = session.execute(average_responses_times).fetchall()
+            return results
+
+    @classmethod
+    def _get_average_responses_times_for_sqlite(
+        cls, start_time, end_time, time_format, endpoint
+    ):
+        """Get average responses time.
+
+        func.strftime is SQLite specific.
+        Use this function in unit test using flexmock:
+
+        flexmock(AnalyzeRequestMetrics).should_receive("_get_average_responses_times_for_postgres")
+        .replace_with(AnalyzeRequestMetrics._get_average_responses_times_for_sqlite)
+        """
+        with transaction(commit=False) as session:
+            average_responses_times = (
+                select(
+                    func.strftime(time_format, cls.request_received_at).label(
+                        "time_range"
+                    ),
+                    (
+                        func.avg(
+                            func.julianday(cls.response_sent_at)
+                            - func.julianday(cls.request_received_at)  # noqa: W503 flake8 vs ruff
+                        )
+                        * 86400  # noqa: W503 flake8 vs ruff
+                    ).label("average_response_seconds"),
+                )
+                .filter(cls.request_received_at.between(start_time, end_time))
+                .filter(cls.endpoint == endpoint)
+                .group_by("time_range")
+                .order_by("time_range")
+            )
+
+            results = session.execute(average_responses_times).fetchall()
+            return results
+
+    @classmethod
+    def get_responses_average_time_in_period(
+        cls,
+        start_time: datetime.datetime,
+        end_time: datetime.datetime,
+        time_format: str,
+        endpoint: Optional[EndpointType] = EndpointType.ANALYZE,
+    ) -> dict[datetime.datetime, int]:
+        """
+        Get a dictionary with average responses times
+        grouped by time units within a specified period.
+
+        Args:
+            start_time (datetime): The start of the time period to query
+            end_time (datetime): The end of the time period to query
+            time_format (str): The strftime format string to format timestamps (e.g., '%Y-%m-%d')
+            endpoint (EndpointType): The analyze API endpoint to query
 
-            return counts_dict
+        Returns:
+            dict[datetime, int]: A dictionary mapping datetime objects
+            to average responses times
+        """
+        with transaction(commit=False) as _:
+            average_responses_times = cls._get_average_responses_times_for_postgres(
+                start_time, end_time, time_format, endpoint
+            )
+
+            return cls.get_dictionary_with_datetime_keys(
+                time_format, average_responses_times
+            )
+
+    @classmethod
+    def _get_average_responses_lengths_for_postgres(
+        cls, start_time, end_time, time_format, endpoint
+    ):
+        """Get average responses length.
+
+        func.to_char is PostgreSQL specific.
+        Let's unit tests replace this function with the SQLite version.
+        """
+        with transaction(commit=False) as session:
+            pgsql_time_format = cls.get_postgres_time_format(time_format)
+
+            average_responses_lengths = (
+                select(
+                    func.to_char(cls.request_received_at, pgsql_time_format).label(
+                        "time_range"
+                    ),
+                    (func.avg(cls.response_length)).label("average_responses_length"),
+                )
+                .filter(cls.request_received_at.between(start_time, end_time))
+                .filter(cls.endpoint == endpoint)
+                .group_by("time_range")
+                .order_by("time_range")
+            )
+
+            results = session.execute(average_responses_lengths).fetchall()
+            return results
+
+    @classmethod
+    def _get_average_responses_lengths_for_sqlite(
+        cls, start_time, end_time, time_format, endpoint
+    ):
+        """Get average responses length.
+
+        func.strftime is SQLite specific.
+        Use this function in unit test using flexmock:
+
+        flexmock(AnalyzeRequestMetrics)
+        .should_receive("_get_average_responses_lengths_for_postgres")
+        .replace_with(AnalyzeRequestMetrics._get_average_responses_lengths_for_sqlite)
+        """
+        with transaction(commit=False) as session:
+            average_responses_lengths = (
+                select(
+                    func.strftime(time_format, cls.request_received_at).label(
+                        "time_range"
+                    ),
+                    (func.avg(cls.response_length)).label("average_responses_length"),
+                )
+                .filter(cls.request_received_at.between(start_time, end_time))
+                .filter(cls.endpoint == endpoint)
+                .group_by("time_range")
+                .order_by("time_range")
+            )
+
+            results = session.execute(average_responses_lengths).fetchall()
+            return results
+
+    @classmethod
+    def get_responses_average_length_in_period(
+        cls,
+        start_time: datetime.datetime,
+        end_time: datetime.datetime,
+        time_format: str,
+        endpoint: Optional[EndpointType] = EndpointType.ANALYZE,
+    ) -> dict[datetime.datetime, int]:
+        """
+        Get a dictionary with average responses length
+        grouped by time units within a specified period.
+
+        Args:
+            start_time (datetime): The start of the time period to query
+            end_time (datetime): The end of the time period to query
+            time_format (str): The strftime format string to format timestamps (e.g., '%Y-%m-%d')
+            endpoint (EndpointType): The analyze API endpoint to query
+
+        Returns:
+            dict[datetime, int]: A dictionary mapping datetime objects
+            to average responses lengths
+        """
+        with transaction(commit=False) as _:
+            average_responses_lengths = cls._get_average_responses_lengths_for_postgres(
+                start_time, end_time, time_format, endpoint
+            )
+
+            return cls.get_dictionary_with_datetime_keys(
+                time_format, average_responses_lengths
+            )

logdetective/server/metric.py

@@ -41,12 +41,10 @@ def update_metrics(
         sent_at if sent_at else datetime.datetime.now(datetime.timezone.utc)
     )
     response_length = None
-    if hasattr(response, "explanation") and "choices" in response.explanation:
-        response_length = sum(
-            len(choice["text"])
-            for choice in response.explanation["choices"]
-            if "text" in choice
-        )
+    if hasattr(response, "explanation") and isinstance(
+        response.explanation, models.Explanation
+    ):
+        response_length = len(response.explanation.text)
     response_certainty = (
         response.response_certainty if hasattr(response, "response_certainty") else None
     )

logdetective/server/models.py

@@ -2,7 +2,9 @@ import datetime
 from logging import BASIC_FORMAT
 from typing import List, Dict, Optional, Literal
 
-from pydantic import BaseModel, Field, model_validator, field_validator
+from pydantic import BaseModel, Field, model_validator, field_validator, NonNegativeFloat
+
+from logdetective.constants import DEFAULT_TEMPERATURE
 
 
 class BuildLog(BaseModel):
@@ -95,6 +97,8 @@ class InferenceConfig(BaseModel):
     )
     url: str = ""
     api_token: str = ""
+    model: str = ""
+    temperature: NonNegativeFloat = DEFAULT_TEMPERATURE
 
     def __init__(self, data: Optional[dict] = None):
         super().__init__()
@@ -106,6 +110,8 @@ class InferenceConfig(BaseModel):
         self.api_endpoint = data.get("api_endpoint", "/chat/completions")
         self.url = data.get("url", "")
         self.api_token = data.get("api_token", "")
+        self.model = data.get("model", "default-model")
+        self.temperature = data.get("temperature", DEFAULT_TEMPERATURE)
 
 
 class ExtractorConfig(BaseModel):
@@ -150,7 +156,8 @@ class LogConfig(BaseModel):
     """Logging configuration"""
 
     name: str = "logdetective"
-    level: str | int = "INFO"
+    level_stream: str | int = "INFO"
+    level_file: str | int = "INFO"
     path: str | None = None
     format: str = BASIC_FORMAT
 
@@ -160,7 +167,8 @@ class LogConfig(BaseModel):
             return
 
         self.name = data.get("name", "logdetective")
-        self.level = data.get("level", "INFO").upper()
+        self.level_stream = data.get("level_stream", "INFO").upper()
+        self.level_file = data.get("level_file", "INFO").upper()
         self.path = data.get("path")
         self.format = data.get("format", BASIC_FORMAT)
 

logdetective/server/plot.py

@@ -1,5 +1,5 @@
 import datetime
-from typing import Optional
+from typing import Optional, Union
 
 import numpy
 import matplotlib
@@ -62,24 +62,24 @@ class Definition:
 
 
 def create_time_series_arrays(
-    counts_dict: dict[datetime.datetime, int],
+    values_dict: dict[datetime.datetime, int],
+    plot_def: Definition,
     start_time: datetime.datetime,
     end_time: datetime.datetime,
-    time_delta: datetime.timedelta,
-    time_format: str,
+    value_type: Optional[Union[int, float]] = int,
 ) -> tuple[numpy.ndarray, numpy.ndarray]:
-    """Create time series arrays from a dictionary of counts.
+    """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 counts for each timestamp
+    2. A corresponding array of valuesfor each timestamp
 
     The timestamps are truncated to the precision specified by time_format.
-    If a timestamp in counts_dict matches a generated timestamp, its count is used;
-    otherwise, the count defaults to zero.
+    If a timestamp in values_dict matches a generated timestamp, its values is used;
+    otherwise, the value defaults to zero.
 
     Args:
-        counts_dict: Dictionary mapping timestamps to their respective counts
+        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
@@ -88,67 +88,70 @@ def create_time_series_arrays(
     Returns:
         A tuple containing:
             - numpy.ndarray: Array of timestamps
-            - numpy.ndarray: Array of corresponding counts
+            - numpy.ndarray: Array of corresponding values
     """
-    num_intervals = int((end_time - start_time) / time_delta) + 1
+    num_intervals = int((end_time - start_time) / plot_def.time_delta) + 1
 
     timestamps = numpy.array(
         [
             datetime.datetime.strptime(
-                (start_time + i * time_delta).strftime(format=time_format), time_format
+                (start_time + i * plot_def.time_delta).strftime(
+                    format=plot_def.time_format
+                ),
+                plot_def.time_format,
             )
             for i in range(num_intervals)
         ]
     )
-    counts = numpy.zeros(num_intervals, dtype=int)
+    values = numpy.zeros(num_intervals, dtype=value_type)
 
     timestamp_to_index = {timestamp: i for i, timestamp in enumerate(timestamps)}
 
-    for timestamp, count in counts_dict.items():
+    for timestamp, count in values_dict.items():
         if timestamp in timestamp_to_index:
-            counts[timestamp_to_index[timestamp]] = count
+            values[timestamp_to_index[timestamp]] = count
 
-    return timestamps, counts
+    return timestamps, values
 
 
-def _add_bar_chart_for_requests_count(
-    ax1: matplotlib.figure.Axes,
+def _add_bar_chart(
+    ax: matplotlib.figure.Axes,
     plot_def: Definition,
     timestamps: numpy.array,
-    counts: numpy.array,
+    values: numpy.array,
+    label: str,
 ) -> None:
-    """Add a bar chart for requests count (axes 1)"""
+    """Add a blue bar chart"""
     bar_width = (
         0.8 * plot_def.time_delta.total_seconds() / 86400
     )  # Convert to days for matplotlib
-    ax1.bar(
+    ax.bar(
         timestamps,
-        counts,
+        values,
         width=bar_width,
         alpha=0.7,
         color="skyblue",
-        label="Requests",
+        label=label,
     )
-    ax1.set_xlabel("Time")
-    ax1.set_ylabel("Requests", color="blue")
-    ax1.tick_params(axis="y", labelcolor="blue")
+    ax.set_xlabel("Time")
+    ax.set_ylabel(label, color="blue")
+    ax.tick_params(axis="y", labelcolor="blue")
 
-    ax1.xaxis.set_major_formatter(matplotlib.dates.DateFormatter(plot_def.time_format))
-    ax1.xaxis.set_major_locator(plot_def.locator)
+    ax.xaxis.set_major_formatter(matplotlib.dates.DateFormatter(plot_def.time_format))
+    ax.xaxis.set_major_locator(plot_def.locator)
 
     matplotlib.pyplot.xticks(rotation=45)
 
-    ax1.grid(True, alpha=0.3)
+    ax.grid(True, alpha=0.3)
 
 
-def _add_cumulative_line_for_requests_count(
-    ax2: matplotlib.figure.Axes, timestamps: numpy.array, counts: numpy.array
+def _add_line_chart(
+    ax: matplotlib.figure.Axes, timestamps: numpy.array, values: numpy.array, label: str
 ) -> None:
-    """Add cumulative line on secondary y-axis"""
-    cumulative = numpy.cumsum(counts)
-    ax2.plot(timestamps, cumulative, "r-", linewidth=2, label="Cumulative")
-    ax2.set_ylabel("Cumulative Requests", color="red")
-    ax2.tick_params(axis="y", labelcolor="red")
+    """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")
 
 
 def requests_per_time(
@@ -183,14 +186,14 @@ def requests_per_time(
         start_time, end_time, plot_def.time_format, endpoint
     )
     timestamps, counts = create_time_series_arrays(
-        requests_counts, start_time, end_time, plot_def.time_delta, plot_def.time_format
+        requests_counts, plot_def, start_time, end_time
     )
 
     fig, ax1 = matplotlib.pyplot.subplots(figsize=(12, 6))
-    _add_bar_chart_for_requests_count(ax1, plot_def, timestamps, counts)
+    _add_bar_chart(ax1, plot_def, timestamps, counts, "Requests")
 
     ax2 = ax1.twinx()
-    _add_cumulative_line_for_requests_count(ax2, timestamps, counts)
+    _add_line_chart(ax2, timestamps, numpy.cumsum(counts), "Cumulative Requests")
 
     matplotlib.pyplot.title(
         f"Requests received for API {endpoint} ({start_time.strftime(plot_def.time_format)} "
@@ -204,3 +207,75 @@ def requests_per_time(
     matplotlib.pyplot.tight_layout()
 
     return fig
+
+
+def average_time_per_responses(  # pylint: disable=too-many-locals
+    period_of_time: models.TimePeriod,
+    endpoint: EndpointType = EndpointType.ANALYZE,
+    end_time: Optional[datetime.datetime] = None,
+) -> matplotlib.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 = 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 = matplotlib.pyplot.subplots(figsize=(12, 6))
+    _add_bar_chart(ax1, plot_def, timestamps, average_time, "average response time (seconds)")
+
+    responses_average_length = (
+        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)")
+
+    matplotlib.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")
+
+    matplotlib.pyplot.tight_layout()
+
+    return fig