PromCopilot: Simplifying Prometheus Metric Querying in Cloud Native Online Service Systems via Large Language Models

Dit artikel introduceert PromCopilot, een framework dat grote taalmodellen en een kennisgrafiek combineert om natuurlijke taalvragen automatisch om te zetten in PromQL-query's voor het vereenvoudigen van het monitoren van cloud-native systemen.

De kern

Hier is een uitleg van het paper "PromCopilot" in eenvoudig Nederlands, met behulp van creatieve analogieën om het begrijpelijk te maken voor iedereen.

🚀 De Uitdaging: De "Grote Boze Wolf" van de Data

Stel je voor dat je een gigantisch, modern ziekenhuis runt. Dit ziekenhuis heeft duizenden apparaten, van MRI-scanners tot de verwarming in de wachtkamers. Elke seconde sturen deze apparaten duizenden signalen: "Ik heb 80% batterij," "De temperatuur is te hoog," of "Ik heb 100 patiënten vandaag."

In de digitale wereld noemen we deze signalen metrieken. Bedrijven gebruiken software (zoals Prometheus) om al deze signalen te bewaken. Als er iets misgaat, moeten ingenieurs snel weten wat er aan de hand is.

Maar hier zit de adder onder het gras: Om deze data te vragen, moeten ingenieurs een heel moeilijke, speciale taal spreken die PromQL heet. Het is alsof je in het ziekenhuis niet gewoon kunt zeggen: "Hoe gaat het met de MRI-machine in kamer 3?" Nee, je moet een ingewikkelde code typen die eruitziet als:
sum(rate(http_requests_total{instance="room3", method="GET"}[5m]))

Als je één klein foutje maakt in die code, krijg je geen antwoord, of erger nog, een verkeerd antwoord. Voor een mens is dit lastig, tijdrovend en stressvol. Je moet niet alleen de code kennen, maar ook precies weten welke machine in welke kamer staat.

🤖 De Oplossing: PromCopilot (Je Digitale Vertaler)

De auteurs van dit paper hebben een slimme oplossing bedacht genaamd PromCopilot.

Stel je voor dat PromCopilot een super-slome tolk is die twee werelden met elkaar verbindt:

1. Jij (de mens): Je spreekt gewoon Nederlands (of Engels).
2. De Computer (Prometheus): Die spreekt alleen die moeilijke PromQL-code.

Met PromCopilot hoef je niet meer die moeilijke code te typen. Je kunt gewoon zeggen: "Welke server heeft de meeste vrije ruimte, waar de bestel-app draait?" En PromCopilot vertaalt dit direct naar de perfecte code voor de computer.

🧠 Hoe werkt het? De "Digitale Landkaart"

Je zou denken: "Wacht even, hoe weet de computer welke server welke is? Die heeft toch geen geheugen?"

Hier komt het slimme deel van het paper. De onderzoekers hebben een Kennisnetwerk (een Knowledge Graph) gebouwd.

• De Analogie: Stel je voor dat je een enorme, digitale landkaart hebt van het hele ziekenhuis. Op deze kaart staat niet alleen waar de MRI's staan, maar ook wie er bij hoort, welke verwarming erbij hoort, en welke signalen ze sturen.
• Het Proces:
  1. Jij stelt je vraag: "Waar is de bestel-app?"
  2. PromCopilot kijkt op de kaart: Hij zoekt op de digitale landkaart waar de "bestel-app" zit. Hij ziet: "Ah, die zit op server A, B en C."
  3. Hij zoekt de juiste signalen: Hij kijkt op de kaart welke signalen die servers sturen (bijv. "vrije ruimte").
  4. De Vertaling: Hij neemt al die informatie en de vraag, en geeft het door aan een AI (een Large Language Model, zoals een heel slimme robot). De AI zegt: "Oké, ik heb de vraag, ik heb de locatie van de servers, en ik weet welke code nodig is. Hier is de perfecte PromQL-code!"

Dit noemen ze synergetisch redeneren: De landkaart (Kennisnetwerk) zorgt voor de feiten, en de AI zorgt voor de taal. Samen maken ze het onmogelijke mogelijk.

📊 Wat hebben ze bewezen?

De onderzoekers hebben dit getest in een laboratorium met een nep-online winkel (een systeem met veel verschillende onderdelen). Ze maakten een lijst van 280 vragen die een mens zou kunnen stellen.

• Het resultaat: PromCopilot slaagde er in 69% van de gevallen om de perfecte code te schrijven.
• Vergelijking: Als je de AI alleen maar vraagt om te raden (zonder de digitale landkaart), lukt het maar in ongeveer 2-5% van de gevallen.
• Snelheid: In een test met echte ingenieurs bleek dat mensen met PromCopilot 3 tot 4 keer sneller waren dan zonder. Ze hoefden niet meer 10 minuten te zoeken naar welke server welke naam had; de AI deed het voor hen.

💡 Waarom is dit belangrijk?

Vroeger moesten ingenieurs als detectives werken, urenlang zoeken in documentatie en code om een simpele vraag te beantwoorden. Met PromCopilot wordt het alsof je een Google hebt voor je systeem. Je vraagt gewoon wat je wilt weten, en het systeem geeft je het antwoord in de taal die de computer begrijpt.

Het paper is uniek omdat het de eerste keer is dat iemand dit specifiek voor deze moeilijke "Prometheus-taal" heeft opgelost. Het maakt complexe technologie toegankelijk voor mensen, zodat ze zich kunnen focussen op het oplossen van problemen in plaats van het typen van code.

Kortom: PromCopilot is de tolk die zorgt dat jij en je computer eindelijk goed met elkaar kunnen praten, zonder dat jij een diploma in computercode nodig hebt.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het paper "PromCopilot: Simplifying Prometheus Metric Querying in Cloud Native Online Service Systems via Large Language Models" in het Nederlands.

Probleemstelling

Moderne online servicesystemen, vaak gebaseerd op cloud-native architecturen (microservices, containers), zijn extreem complex. Om de betrouwbaarheid en stabiliteit van deze systemen te garanderen, maken ingenieurs gebruik van metriek-monitoringssystemen zoals Prometheus. Ingenieurs moeten echter handmatig PromQL (Prometheus Query Language) queries schrijven om data te analyseren, fouten te diagnosticeren of prestaties te optimaliseren.

Dit proces kent twee grote uitdagingen:

1. Hoge leercurve: PromQL is een domein-specifieke taal (DSL) die complexe syntaxis vereist.
2. Contextafhankelijkheid: Het schrijven van een correcte query vereist niet alleen kennis van de taal, maar ook diepgaande kennis van de specifieke systeemcontext (bijv. welke services op welke nodes draaien, hoe componenten met elkaar verbonden zijn, en de exacte namen van metrieken en labels). In dynamische cloud-omgevingen verandert deze context voortdurend, wat het zoeken naar de juiste informatie tijdrovend maakt.

Bestaande oplossingen zoals tekst-naar-SQL of generieke code-generatie door Large Language Models (LLMs) zijn niet direct toepasbaar, omdat ze vaak geen toegang hebben tot deze specifieke, private systeemcontext en moeite hebben met multi-hop redenering (bijv. "vind de nodes waar service X draait en haal daar de CPU-metriek op").

Methodologie: PromCopilot

Het paper introduceert PromCopilot, een framework dat natuurlijke taal vraagt om te vertalen naar PromQL queries. De kerninnovatie is de synergie tussen een Kennisgrafiek (Knowledge Graph - KG) en een LLM.

Het proces verloopt in vier hoofdstappen:

1. Constructie van de Systeemcontext Kennisgrafiek:

   • PromCopilot bouwt automatisch een kennisgrafiek op basis van diverse databronnen: Prometheus-metadata, Kubernetes-resources, gedistribueerde traces en systeemdocumentatie.
   • De grafiek bevat entiteiten voor systeemcomponenten (Nodes, Pods, Services, Containers, APIs) en metriekdata (Metrics, Label-Value Pairs).
   • Relaties worden gedefinieerd tussen deze entiteiten (bijv. een Service targett een Pod, een Pod host op een Node, een Metric heeft een Label).

2. Vraag Parsing (Question Parsing):

   • De natuurlijke taalvraag van de gebruiker wordt door de LLM geanalyseerd.
   • Er worden twee soorten informatie geëxtraheerd:
     • Component Relation Paths: Paden die de relaties tussen componenten beschrijven (bijv. Service -> Pod -> Node), zelfs als specifieke namen ontbreken (dan worden placeholders gebruikt).
     • Metric-Component Pairs: Welke metriek wordt gevraagd en aan welk type component deze gekoppeld is.

3. Kennis Retrieval (Informatie Opvragen):

   • Systeemcomponenten: Op basis van de geëxtraheerde paden zoekt het systeem in de kennisgrafiek naar concrete "redeneringspaden" (reasoning paths) die de daadwerkelijke deploy-structuur van het moment weergeven.
   • Metriekkennis: Het systeem zoekt naar de juiste metrieknamen en label-waarden die relevant zijn voor de vraag, gebruikmakend van semantische zoekopdrachten (BM25) en de context van de geïdentificeerde componenten.

4. Query Generatie:

   • De originele vraag, samen met de opgehaalde kennis (metriekdetails en redeneringspaden), wordt als context aan de LLM gegeven.
   • De LLM genereert de uiteindelijke PromQL-query.

Belangrijkste Bijdragen

1. PromCopilot Framework: Het eerste framework dat natuurlijke taal naar PromQL vertaalt door gebruik te maken van een kennisgrafiek voor contextbewust redeneren in plaats van alleen op historische data te vertrouwen.
2. Eerste Benchmark Dataset: De auteurs hebben handmatig de eerste text-to-PromQL dataset samengesteld met 280 vraag-antwoordparen, gebaseerd op het open-source TrainTicket microservice-systeem. Deze dataset is publiek beschikbaar.
3. Validatie: Uitgebreide experimenten die de effectiviteit van de aanpak aantonen, inclusief een pilot-studie met industriële ingenieurs.

Resultaten

De evaluatie werd uitgevoerd met GPT-4-Turbo en DeepSeek-Coder-V2-236B als backbone LLMs.

• Algemene Nauwkeurigheid (QueryAcc): PromCopilot behaalde een nauwkeurigheid van 69,1% (met GPT-4-Turbo) bij het genereren van correcte PromQL-queries. Dit is aanzienlijk hoger dan baselines:
  • Basic Prompt: 2,6%
  • Few-shot Learning (10-shot): 37,4%
• Metriek Retrieval: De precisie en recall voor het vinden van de juiste metrieken waren zeer hoog (respectievelijk 90,7% en 90,3%).
• Redeneringspaden: De recall voor het vinden van de juiste systeemcomponent-relaties was 90,8%.
• User Study: In een pilot met 8 ervaren ingenieurs bleek PromCopilot de tijd om een query te schrijven te reduceren van gemiddeld 382 seconden (met andere tools) naar 101 seconden. De gebruikers scoorden het hulpmiddel hoog op bruikbaarheid (3,75/4) en correctheid (3,5/4).

Betekenis en Impact

• Efficiëntie: PromCopilot verlaagt de drempel voor het werken met complexe monitoringdata, waardoor ingenieurs sneller inzichten kunnen krijgen in systeemgedrag zonder diepgaande PromQL-expertise of tijd te verliezen met het zoeken naar contextinformatie.
• AIOps Vooruitgang: Het paper toont aan dat het combineren van kennisgrafieken met LLMs een effectieve strategie is voor AIOps-taken waar pure data-gedreven benaderingen (zoals few-shot learning op historische logs) tekortschieten vanwege de dynamische aard van cloud-systemen.
• Pionierswerk: Als eerste studie op het gebied van text-to-PromQL, legt het de basis voor verdere research in het automatiseren van monitoring en observability in cloud-native omgevingen.

Kortom, PromCopilot lost het probleem van de "contextkloof" op tussen natuurlijke taalvragen en technische monitoringqueries, waardoor het een waardevol hulpmiddel is voor de betrouwbaarheid van moderne online diensten.