logdetective 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

logdetective/constants.py

@@ -1,6 +1,6 @@
 
 # pylint: disable=line-too-long
-DEFAULT_ADVISOR = "TheBloke/Mistral-7B-Instruct-v0.2-GGUF"
+DEFAULT_ADVISOR = "fedora-copr/Mistral-7B-Instruct-v0.2-GGUF"
 
 PROMPT_TEMPLATE = """
 Given following log snippets, and nothing else, explain what failure, if any, occured during build of this package.
@@ -30,3 +30,16 @@ Log:
 Answer:
 
 """
+
+SNIPPET_PROMPT_TEMPLATE = """
+Analyse following RPM build log snippet.
+Analysis of the snippets must be in a format of [X] : [Y], where [X] is a log snippet, and [Y] is the explanation.
+Snippets themselves must not be altered in any way whatsoever.
+
+Snippet:
+
+{}
+
+Analysis:
+
+"""

logdetective/logdetective.py

@@ -3,14 +3,14 @@ import logging
 import sys
 
 from logdetective.constants import DEFAULT_ADVISOR
-from logdetective.utils import process_log, initialize_model, retrieve_log_content, format_snippets
+from logdetective.utils import (
+    process_log, initialize_model, retrieve_log_content, format_snippets, compute_certainty)
 from logdetective.extractors import LLMExtractor, DrainExtractor
 
 LOG = logging.getLogger("logdetective")
 
-
-def main():
-    """Main execution function."""
+def setup_args():
+    """ Setup argument parser and return arguments. """
     parser = argparse.ArgumentParser("logdetective")
     parser.add_argument("file", type=str,
                         default="", help="The URL or path to the log file to be analyzed.")
@@ -21,6 +21,7 @@ def main():
                         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_S.gguf")
+    parser.add_argument("-n", "--no-stream", action='store_true')
     parser.add_argument("-S", "--summarizer", type=str, default="drain",
                         help="Choose between LLM and Drain template miner as the log summarizer.\
                                 LLM must be specified as path to a model, URL or local file.")
@@ -32,7 +33,12 @@ def main():
                             This only makes sense when you are summarizing with Drain")
     parser.add_argument("-v", "--verbose", action='count', default=0)
     parser.add_argument("-q", "--quiet", action='store_true')
-    args = parser.parse_args()
+    return parser.parse_args()
+
+
+def main():
+    """Main execution function."""
+    args = setup_args()
 
     if args.verbose and args.quiet:
         sys.stderr.write("Error: --quiet and --verbose is mutually exclusive.\n")
@@ -83,7 +89,25 @@ def main():
     log_summary = format_snippets(log_summary)
     LOG.info("Log summary: \n %s", log_summary)
 
-    print(f"Explanation: \n{process_log(log_summary, model)}")
+    stream = True
+    if args.no_stream:
+        stream = False
+    response = process_log(log_summary, model, stream)
+    probs = []
+    print("Explanation:")
+    if args.no_stream:
+        print(response["choices"][0]["text"])
+        probs = response["choices"][0]["logprobs"]["top_logprobs"]
+    else:
+        # Stream the output
+        for chunk in response:
+            if isinstance(chunk["choices"][0]["logprobs"], dict):
+                probs.extend(chunk["choices"][0]["logprobs"]["top_logprobs"])
+            delta = chunk['choices'][0]['text']
+            print(delta, end='', flush=True)
+    certainty = compute_certainty(probs)
+
+    print(f"\nResponse certainty: {certainty:.2f}%\n")
 
 
 if __name__ == "__main__":

logdetective/server.py

@@ -1,56 +1,192 @@
+import json
 import logging
 import os
-import json
+from typing import List
 
-from fastapi import FastAPI
+from llama_cpp import CreateCompletionResponse
+from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
 
 import requests
 
-from logdetective.constants import PROMPT_TEMPLATE
+from logdetective.constants import PROMPT_TEMPLATE, SNIPPET_PROMPT_TEMPLATE
 from logdetective.extractors import DrainExtractor
-
+from logdetective.utils import validate_url, compute_certainty
 
 class BuildLog(BaseModel):
     """Model of data submitted to API.
     """
     url: str
 
+
+class Response(BaseModel):
+    """Model of data returned by Log Detective API
+
+    explanation: CreateCompletionResponse
+        https://llama-cpp-python.readthedocs.io/en/latest/api-reference/#llama_cpp.llama_types.CreateCompletionResponse
+    response_certainty: float
+    """
+    explanation: CreateCompletionResponse
+    response_certainty: float
+
+
+class StagedResponse(Response):
+    """Model of data returned by Log Detective API when called when staged response
+    is requested. Contains list of reponses to prompts for individual snippets.
+
+    explanation: CreateCompletionResponse
+        https://llama-cpp-python.readthedocs.io/en/latest/api-reference/#llama_cpp.llama_types.CreateCompletionResponse
+    response_certainty: float
+    snippets: list of CreateCompletionResponse
+    """
+    snippets: List[CreateCompletionResponse]
+
+
 LOG = logging.getLogger("logdetective")
 
 app = FastAPI()
 
-LLM_CPP_SERVER_ADDRESS = os.environ.get("LLAMA_CPP_SERVER", " http://localhost")
+LLM_CPP_HOST = os.environ.get("LLAMA_CPP_HOST", "localhost")
+LLM_CPP_SERVER_ADDRESS = f"http://{LLM_CPP_HOST}"
 LLM_CPP_SERVER_PORT = os.environ.get("LLAMA_CPP_SERVER_PORT", 8000)
 LLM_CPP_SERVER_TIMEOUT = os.environ.get("LLAMA_CPP_SERVER_TIMEOUT", 600)
 LOG_SOURCE_REQUEST_TIMEOUT = os.environ.get("LOG_SOURCE_REQUEST_TIMEOUT", 60)
 
-@app.post("/analyze", )
-async def analyze_log(build_log: BuildLog):
-    """Provide endpoint for log file submission and analysis.
-    Request must be in form {"url":"<YOUR_URL_HERE>"}.
+
+def process_url(url: str) -> str:
+    """Validate log URL and return log text.
+    """
+    if validate_url(url=url):
+        try:
+            log_request = requests.get(url, timeout=int(LOG_SOURCE_REQUEST_TIMEOUT))
+        except requests.RequestException as ex:
+            raise HTTPException(
+                status_code=400,
+                detail=f"We couldn't obtain the logs: {ex}") from ex
+
+        if not log_request.ok:
+            raise HTTPException(status_code=400,
+                                detail="Something went wrong while getting the logs: "
+                                    f"[{log_request.status_code}] {log_request.text}")
+    else:
+        LOG.error("Invalid URL received ")
+        raise HTTPException(status_code=400,
+                            detail=f"Invalid log URL: {url}")
+
+    return log_request.text
+
+
+def mine_logs(log: str) -> List[str]:
+    """Extract snippets from log text
     """
     extractor = DrainExtractor(verbose=True, context=True, max_clusters=8)
 
     LOG.info("Getting summary")
-
-    log = requests.get(build_log.url, timeout=int(LOG_SOURCE_REQUEST_TIMEOUT)).text
     log_summary = extractor(log)
 
     ratio = len(log_summary) / len(log.split('\n'))
     LOG.debug("Log summary: \n %s", log_summary)
     LOG.info("Compression ratio: %s", ratio)
 
+
+    return log_summary
+
+def submit_text(text: str, max_tokens: int = 0, log_probs: int = 1):
+    """Submit prompt to LLM.
+    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
+    """
     LOG.info("Analyzing the text")
     data = {
-            "prompt": PROMPT_TEMPLATE.format(log_summary),
-            "max_tokens": "0"}
+            "prompt": text,
+            "max_tokens": str(max_tokens),
+            "logprobs": str(log_probs)}
+
+    try:
+        # Expects llama-cpp server to run on LLM_CPP_SERVER_ADDRESS:LLM_CPP_SERVER_PORT
+        response = requests.post(
+            f"{LLM_CPP_SERVER_ADDRESS}:{LLM_CPP_SERVER_PORT}/v1/completions",
+            headers={"Content-Type":"application/json"},
+            data=json.dumps(data),
+            timeout=int(LLM_CPP_SERVER_TIMEOUT))
+    except requests.RequestException as ex:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Llama-cpp query failed: {ex}") from ex
+
+    if not response.ok:
+        raise HTTPException(
+            status_code=400,
+            detail="Something went wrong while getting a response from the llama server: "
+                f"[{response.status_code}] {response.text}")
+    try:
+        response = json.loads(response.text)
+    except UnicodeDecodeError as ex:
+        LOG.error("Error encountered while parsing llama server response: %s", ex)
+        raise HTTPException(
+            status_code=400,
+            detail=f"Couldn't parse the response.\nError: {ex}\nData: {response.text}") from ex
+
+    return CreateCompletionResponse(response)
+
+
+@app.post("/analyze", response_model=Response)
+async def analyze_log(build_log: BuildLog):
+    """Provide endpoint for log file submission and analysis.
+    Request must be in form {"url":"<YOUR_URL_HERE>"}.
+    URL must be valid for the request to be passed to the LLM server.
+    Meaning that it must contain appropriate scheme, path and netloc,
+    while lacking  result, params or query fields.
+    """
+    log_text = process_url(build_log.url)
+    log_summary = mine_logs(log_text)
+    response = submit_text(PROMPT_TEMPLATE.format(log_summary))
+
+    if "logprobs" in response["choices"][0]:
+        try:
+            certainty = compute_certainty(
+                response["choices"][0]["logprobs"]["top_logprobs"])
+        except ValueError as ex:
+            LOG.error("Error encountered while computing certainty: %s", ex)
+            raise HTTPException(
+                status_code=400,
+                detail=f"Couldn't compute certainty with data:\n"
+                f"{response["choices"][0]["logprobs"]["top_logprobs"]}") from ex
+
+    return Response(explanation=response, response_certainty=certainty)
+
+
+@app.post("/analyze/staged", response_model=StagedResponse)
+async def analyze_log_staged(build_log: BuildLog):
+    """Provide endpoint for log file submission and analysis.
+    Request must be in form {"url":"<YOUR_URL_HERE>"}.
+    URL must be valid for the request to be passed to the LLM server.
+    Meaning that it must contain appropriate scheme, path and netloc,
+    while lacking  result, params or query fields.
+    """
+    log_text = process_url(build_log.url)
+    log_summary = mine_logs(log_text)
+
+    analyzed_snippets = []
+
+    for snippet in log_summary:
+        response = submit_text(SNIPPET_PROMPT_TEMPLATE.format(snippet))
+        analyzed_snippets.append(response)
+
+    final_analysis = submit_text(
+        PROMPT_TEMPLATE.format([e["choices"][0]["text"] for e in analyzed_snippets]))
 
-    # Expects llama-cpp server to run on LLM_CPP_SERVER_ADDRESS:LLM_CPP_SERVER_PORT
-    response = requests.post(
-        f"{LLM_CPP_SERVER_ADDRESS}:{LLM_CPP_SERVER_PORT}/v1/completions",
-        headers={"Content-Type":"application/json"},
-        data=json.dumps(data),
-        timeout=int(LLM_CPP_SERVER_TIMEOUT))
+    certainty = 0
+    if "logprobs" in final_analysis["choices"][0]:
+        try:
+            certainty = compute_certainty(
+                final_analysis["choices"][0]["logprobs"]["top_logprobs"])
+        except ValueError as ex:
+            LOG.error("Error encountered while computing certainty: %s", ex)
+            raise HTTPException(
+                status_code=400,
+                detail=f"Couldn't compute certainty with data:\n"
+                f"{final_analysis["choices"][0]["logprobs"]["top_logprobs"]}") from ex
 
-    return response.text
+    return StagedResponse(
+        explanation=final_analysis, snippets=analyzed_snippets, response_certainty=certainty)

logdetective/utils.py

@@ -1,10 +1,11 @@
 import logging
 import os
+from typing import Iterator, List, Dict
 from urllib.parse import urlparse
-
+import numpy as np
 import requests
 
-from llama_cpp import Llama
+from llama_cpp import Llama, CreateCompletionResponse, CreateCompletionStreamResponse
 from logdetective.constants import PROMPT_TEMPLATE
 
 
@@ -53,24 +54,45 @@ def initialize_model(model_pth: str, filename_suffix: str = ".gguf", verbose: bo
         filename_suffix (str): suffix of the model file name to be pulled from Hugging Face
         verbose (bool): level of verbosity for llamacpp
     """
+
+    LOG.info("Loading model from %s", model_pth)
+
     if os.path.isfile(model_pth):
         model = Llama(
             model_path=model_pth,
             n_ctx=0,  # Maximum context for the model
-            verbose=verbose)
+            verbose=verbose,
+            logits_all=True)
     else:
         model = Llama.from_pretrained(
             model_pth,
             f"*{filename_suffix}",
             n_ctx=0,  # Maximum context for the model
-            verbose=verbose)
+            verbose=verbose,
+            logits_all=True)
 
     return model
 
 
-def process_log(log: str, model: Llama) -> str:
+def compute_certainty(probs: List[Dict[str, float] | None]) -> float:
+    """Compute certainty of repsponse based on average logit probability.
+    Log probability is log(p), isn't really readable for most people, especially in compound.
+    In this case it's just a matter of applying inverse operation exp.
+    Of course that leaves you with a value in range <0, 1> so it needs to be multiplied by 100.
+    Simply put, this is the most straightforward way to get the numbers out.
     """
-    Processes a given log using the provided language model and returns its summary.
+
+    top_logprobs = [
+        np.exp(x) * 100 for e in probs if isinstance(e, dict) for x in e.values()]
+    certainty = np.median(top_logprobs, axis=0)
+    if np.isnan(certainty):
+        raise ValueError("NaN certainty of answer")
+    return certainty
+
+
+def process_log(log: str, model: Llama, stream: bool) -> (
+        CreateCompletionResponse | Iterator[CreateCompletionStreamResponse]):
+    """Processes a given log using the provided language model and returns its summary.
 
     Args:
         log (str): The input log to be processed.
@@ -79,11 +101,19 @@ def process_log(log: str, model: Llama) -> str:
     Returns:
         str: The summary of the given log generated by the language model.
     """
-    return model(PROMPT_TEMPLATE.format(log), max_tokens=0)["choices"][0]["text"]
+    response = model(
+        prompt=PROMPT_TEMPLATE.format(log),
+        stream=stream,
+        max_tokens=0,
+        logprobs=1)
+
+    return response
 
 
 def retrieve_log_content(log_path: str) -> str:
-    """Get content of the file on the log_path path."""
+    """Get content of the file on the log_path path.
+    Path is assumed to be valid URL if it has a scheme.
+    Otherwise it attempts to pull it from local filesystem."""
     parsed_url = urlparse(log_path)
     log = ""
 
@@ -113,3 +143,18 @@ def format_snippets(snippets: list[str]) -> str:
         ================
         """
     return summary
+
+
+def validate_url(url: str) -> bool:
+    """Validate incoming URL to be at least somewhat sensible for log files
+    Only http and https protocols permitted. No result, params or query fields allowed.
+    Either netloc or path must have non-zero length.
+    """
+    result = urlparse(url)
+    if result.scheme not in ['http', 'https']:
+        return False
+    if any([result.params, result.query, result.fragment]):
+        return False
+    if not (result.path or result.netloc):
+        return False
+    return True

{logdetective-0.2.5.dist-info → logdetective-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: logdetective
-Version: 0.2.5
+Version: 0.2.7
 Summary: Log using LLM AI to search for build/test failures and provide ideas for fixing these.
 License: Apache-2.0
 Author: Jiri Podivin
@@ -21,6 +21,7 @@ Provides-Extra: server
 Requires-Dist: drain3 (>=0.9.11,<0.10.0)
 Requires-Dist: huggingface-hub (>0.23.2)
 Requires-Dist: llama-cpp-python (>=0.2.56,<0.3.0,!=0.2.86)
+Requires-Dist: numpy (>=1.26.0,<2.0.0)
 Requires-Dist: requests (>=2.31.0,<3.0.0)
 Project-URL: homepage, https://github.com/fedora-copr/logdetective
 Project-URL: issues, https://github.com/fedora-copr/logdetective/issues
@@ -38,7 +39,7 @@ A Python tool to analyze logs using a Language Model (LLM) and Drain template mi
 Installation
 ------------
 
-** Fedora 40+ **
+**Fedora 40+**
 
     dnf install logdetective
 
@@ -83,6 +84,10 @@ Example you want to use a different model:
     logdetective https://example.com/logs.txt --model https://huggingface.co/QuantFactory/Meta-Llama-3-8B-Instruct-GGUF/resolve/main/Meta-Llama-3-8B-Instruct.Q5_K_S.gguf?download=true
     logdetective https://example.com/logs.txt --model QuantFactory/Meta-Llama-3-8B-Instruct-GGUF
 
+Note that streaming with some models (notably Meta-Llama-3 is broken) is broken and can be workarounded by `no-stream` option:
+
+    logdetective https://example.com/logs.txt --model QuantFactory/Meta-Llama-3-8B-Instruct-GGUF --no-stream
+
 
 Real Example
 ------------
@@ -181,7 +186,7 @@ or
 Server
 ------
 
-FastApi based server is implemented in `logdetective/server.py`. In order to run in a development mode,
+FastApi based server is implemented in `logdetective/server.py`. In order to run it in a development mode,
 simply start llama-cpp-python server with your chosen model as described in llama-cpp-python [docs](https://llama-cpp-python.readthedocs.io/en/latest/server/#running-the-server).
 
 Afterwards, start the logdetective server with `fastapi dev logdetective/server.py --port 8080`.
@@ -189,6 +194,17 @@ Requests can then be made with post requests, for example:
 
     curl --header "Content-Type: application/json" --request POST --data '{"url":"<YOUR_URL_HERE>"}' http://localhost:8080/analyze
 
+We also have a Containerfile and composefile to run the logdetective server and llama server in containers.
+
+Before doing `podman-compose up`, make sure to set `MODELS_PATH` environment variable and point to a directory with your local model files:
+```
+$ export MODELS_PATH=/path/to/models/
+$ ll $MODELS_PATH
+-rw-r--r--. 1 tt tt 3.9G apr 10 17:18  mistral-7b-instruct-v0.2.Q4_K_S.gguf
+```
+
+If the variable is not set, `./models` is mounted inside by default.
+
 
 License
 -------

logdetective-0.2.7.dist-info/RECORD

@@ -0,0 +1,12 @@
+logdetective/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+logdetective/constants.py,sha256=1Ls2VJXb7NwSgi_HmTOA1c52K16SZIeDYBXlvBJ07zU,991
+logdetective/drain3.ini,sha256=ni91eCT1TwTznZwcqWoOVMQcGEnWhEDNCoTPF7cfGfY,1360
+logdetective/extractors.py,sha256=eRizRiKhC3MPTHXS5nlRKcEudEaqct7G28V1bZYGkqI,3103
+logdetective/logdetective.py,sha256=f7ASCJg_Yt6VBFieXBYgQYdenfXjC60ZdLHhzQHideI,4372
+logdetective/server.py,sha256=m0NPtk9tAUzyu9O8jIAfgEzynZ-WCHqVvCJkHOm08Ks,7073
+logdetective/utils.py,sha256=nTbaDVEfbHVQPTZe58T04HHZ6JWUJ1PonRRnzGX8hY0,4794
+logdetective-0.2.7.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+logdetective-0.2.7.dist-info/METADATA,sha256=3iqnKnVJy6aTaAqP77btyqSGqCpjT8_PQqpWaNwLKHg,9100
+logdetective-0.2.7.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+logdetective-0.2.7.dist-info/entry_points.txt,sha256=3K_vXja6PmcA8sNdUi63WdImeiNhVZcEGPTaoJmltfA,63
+logdetective-0.2.7.dist-info/RECORD,,

logdetective-0.2.5.dist-info/RECORD

@@ -1,12 +0,0 @@
-logdetective/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-logdetective/constants.py,sha256=ObrYDQiPvZwCpokLbLQoSY_w_-wHl7l94EkXae7Xgq0,708
-logdetective/drain3.ini,sha256=ni91eCT1TwTznZwcqWoOVMQcGEnWhEDNCoTPF7cfGfY,1360
-logdetective/extractors.py,sha256=eRizRiKhC3MPTHXS5nlRKcEudEaqct7G28V1bZYGkqI,3103
-logdetective/logdetective.py,sha256=8pCnkXJ2qfSmXGHoKmTichLiI9tMAot3OOge2lgQBuI,3545
-logdetective/server.py,sha256=GAU6mggoZSf-ER3AHhmd7BKGDLh5ZcsnmkdHTFd_lTU,1715
-logdetective/utils.py,sha256=XRqVvPbAQ0ZAHGivHhAA1kTY8Tv6JAeSsA7gMMoPz8E,3034
-logdetective-0.2.5.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-logdetective-0.2.5.dist-info/METADATA,sha256=nSobNDJzk6iOUl0oqFRNV9Ha0LLCLDbL8uLsX3aPnWY,8362
-logdetective-0.2.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-logdetective-0.2.5.dist-info/entry_points.txt,sha256=3K_vXja6PmcA8sNdUi63WdImeiNhVZcEGPTaoJmltfA,63
-logdetective-0.2.5.dist-info/RECORD,,