Van terabytes naar inzichten: een realistische AI-observatiearchitectuur

Overweeg het onderhouden en ontwikkelen van een e-commerceplatform dat miljoenen transacties per minuut verwerkt en enorme hoeveelheden telemetriegegevens genereert, waaronder statistieken, logs en traces over meerdere microservices. Wanneer zich kritieke incidenten voordoen, staan oproepbare engineers voor de lastige taak om door een oceaan aan data te spitten en relevante signalen en inzichten te achterhalen. Dit is vergelijkbaar met het zoeken naar een speld in een hooiberg.

Dit maakt observatie eerder een bron van frustratie dan van inzicht. Om dit grote knelpunt te verlichten, ben ik op zoek gegaan naar een oplossing om het Model Context Protocol (MCP) te gebruiken om context toe te voegen en conclusies te trekken uit de logs en gedistribueerde traces. In dit artikel beschrijf ik mijn ervaringen met het bouwen van een AI-gestuurd observatieplatform, leg ik de systeemarchitectuur uit en deel ik bruikbare inzichten die ik gaandeweg heb opgedaan.

In moderne softwaresystemen is observatie geen luxe; het is een basisbehoefte. Het vermogen om systeemgedrag te meten en te begrijpen is essentieel voor betrouwbaarheid, prestaties en gebruikersvertrouwen. Zoals het gezegde luidt: "Wat je niet kunt meten, kun je niet verbeteren."

Toch is het moeilijker dan ooit om observatie te realiseren in de huidige cloud-native, op microservices gebaseerde architecturen. Eén enkele gebruikersaanvraag kan tientallen microservices doorkruisen, die elk logs, statistieken en traces genereren. Het resultaat is een overvloed aan telemetriegegevens:

• Tientallen terabytes aan logs per dag
• Tientallen miljoenen metrische datapunten en vooraf samengestelde gegevens
• Miljoenen verspreide sporen
• Elke minuut worden duizenden correlatie-ID's gegenereerd

De uitdaging is niet alleen de hoeveelheid data, maar ook de datafragmentatie. Volgens het Observability Forecast Report 2023 van New Relic rapporteert 50% van de organisaties gefragmenteerde telemetriedata, terwijl slechts 33% een uniform beeld krijgt van alle statistieken, logs en traces.

Logs vertellen één deel van het verhaal, statistieken een ander, traces weer een ander. Zonder een consistente contextuele draad zijn engineers gedwongen tot handmatige correlatie, waarbij ze vertrouwen op intuïtie, stamkennis en saai speurwerk tijdens incidenten.

Vanwege deze complexiteit begon ik me af te vragen: hoe kan AI ons helpen om voorbij gefragmenteerde data te kijken en uitgebreide, bruikbare inzichten te bieden? Kunnen we telemetriegegevens concreet betekenisvoller en toegankelijker maken voor zowel mensen als machines met behulp van een gestructureerd protocol als MCP ? Die centrale vraag vormde de basis van dit project.

Anthropic definieert MCP als een open standaard waarmee ontwikkelaars een veilige tweerichtingsverbinding kunnen creëren tussen databronnen en AI-tools. Deze gestructureerde datapijplijn omvat:

• Contextuele ETL voor AI: standaardiseer context-extractie uit meerdere gegevensbronnen.
• Gestructureerde query-interface: Hiermee kunnen AI-query's toegang krijgen tot gegevenslagen die transparant en eenvoudig te begrijpen zijn.
• Semantische gegevensverrijking: integreert zinvolle context rechtstreeks in telemetriesignalen.

Dit kan ertoe leiden dat de observatiemogelijkheden van het platform verschuiven van reactieve probleemoplossing naar proactieve inzichten.

Voordat we ingaan op de implementatiedetails, bekijken we eerst de systeemarchitectuur.

In de eerste laag ontwikkelen we de contextuele telemetriegegevens door gestandaardiseerde metadata, zoals gedistribueerde traces, logs en metrics, in de telemetriesignalen in te bedden. Vervolgens worden in de tweede laag verrijkte gegevens naar de MCP-server gestuurd om contextverrijkte gegevens te indexeren, te structureren en clienttoegang te bieden via API's. Ten slotte gebruikt de AI-gestuurde analyse-engine de gestructureerde en verrijkte telemetriegegevens voor anomaliedetectie, correlatie en analyse van de hoofdoorzaak om applicatieproblemen op te lossen.

Dankzij dit gelaagde ontwerp krijgen AI- en engineeringteams contextgestuurde, bruikbare inzichten uit telemetriegegevens.

Laten we de daadwerkelijke implementatie van ons MCP-gestuurde observatieplatform eens bekijken, waarbij we ons richten op de gegevensstromen en transformaties bij elke stap.

Laag 1: Generatie van contextverrijkte gegevens

Ten eerste moeten we ervoor zorgen dat onze telemetriegegevens voldoende context bevatten voor zinvolle analyse. De kerngedachte is dat datacorrelatie moet plaatsvinden tijdens het creëren, niet tijdens de analyse.

def process_checkout(user_id, cart_items, payment_method): “””Simuleer een afrekenproces met contextverrijkte telemetrie.””” # Genereer correlatie-ID order_id = f”order-{uuid.uuid4().hex[:8]}” request_id = f”req-{uuid.uuid4().hex[:8]}” # Initialiseer contextwoordenboek dat zal worden toegepast context = { “gebruikers_id”: gebruikers_id, “order_id”: order_id, “aanvraag_id”: aanvraag_id, “winkelwagen_items_aantal”: len(winkelwagen_items), “betaalmethode”: betaalmethode, “service_naam”: “afrekenen”, “service_versie”: “v1.0.0” } # Start OTel-trace met dezelfde context met tracer.start_as_current_span( “process_checkout”, attributes={k: str(v) voor k, v in context.items()} ) als checkout_span: # Loggen met dezelfde context logger.info(f”Starten van het afrekenproces”, extra={“context”: json.dumps(context)}) # Contextvoortplanting met tracer.start_as_current_span(“process_payment”): # Betalingslogica verwerken… logger.info(“Betaling verwerkt”, extra={“context”: json.dumps(context)})

Code 1. Contextverrijking voor logs en traces

Deze aanpak zorgt ervoor dat elk telemetriesignaal (logboeken, statistieken, traceringen) dezelfde contextuele kerngegevens bevat, waardoor het correlatieprobleem bij de bron wordt opgelost.

Vervolgens heb ik een MCP-server gebouwd die ruwe telemetrie omzet in een querybare API. De belangrijkste databewerkingen omvatten het volgende:

1. Indexering : efficiënte opzoekacties maken in contextuele velden
2. Filteren : relevante subsets van telemetriegegevens selecteren
3. Aggregatie : het berekenen van statistische metingen over tijdvensters heen

@app.post(“/mcp/logs”, response_model=List[Log])def query_logs(query: LogQuery): “””Logboeken opvragen met specifieke filters””” results = LOG_DB.copy() # Contextuele filters toepassen als query.request_id: resultaten = [log voor inlogresultaten als log[“context”].get(“request_id”) == query.request_id] als query.user_id: resultaten = [log voor inlogresultaten als log[“context”].get(“user_id”) == query.user_id] # Pas tijdgebaseerde filters toe als query.time_range: start_time = datetime.fromisoformat(query.time_range[“start”]) end_time = datetime.fromisoformat(query.time_range[“end”]) resultaten = [log voor inlogresultaten als start_time <= datetime.fromisoformat(log[“timestamp”]) <= end_time] # Sort op tijdstempel resultaten = gesorteerd(resultaten, sleutel=lambda x: x[“tijdstempel”], omgekeerd=True) retourneer resultaten[:query.limit] als query.limit anders resultaten

Code 2. Gegevenstransformatie met behulp van de MCP-server

Deze laag transformeert onze telemetrie van een ongestructureerd datameer naar een gestructureerde, query-geoptimaliseerde interface waar een AI-systeem efficiënt doorheen kan navigeren.

De laatste laag is een AI-component die gegevens via de MCP-interface verbruikt en het volgende doet:

1. Multidimensionale analyse : correleren van signalen over logs, statistieken en traceringen.
2. Anomaliedetectie : statistische afwijkingen van normale patronen identificeren.
3. Vaststellen van de grondoorzaak : Gebruik van contextuele aanwijzingen om waarschijnlijke oorzaken van problemen te isoleren.

def analyze_incident(self, request_id=None, user_id=None, timeframe_minutes=30): “””Analyseer telemetriegegevens om de grondoorzaak en aanbevelingen te bepalen.””” # Definieer analysetijdvenster eindtijd = datetime.now() starttijd = eindtijd – timedelta(minuten=tijdsbestek_minuten) tijdsbereik = {“start”: starttijd.isoformat(), “einde”: eindtijd.isoformat()} # Haal relevante telemetrie op op basis van context logs = self.fetch_logs(request_id=request_id, user_id=user_id, time_range=tijdsbereik) # Extraheer services die in logs worden genoemd voor gerichte metrische analyse services = set(log.get(“service”, “onbekend”) voor inloglogs) # Haal statistieken op voor die services metrics_by_service = {} voor service in services: voor metric_name in [“latentie”, “foutpercentage”, “doorvoer”]: metric_data = self.fetch_metrics(service, metric_name, tijdsbereik) # Statistische eigenschappen berekenen waarden = [punt[“waarde”] voor punt in metric_data[“data_points”]] metrics_by_service[f”{service}.{metric_name}”] = { “gemiddelde”: statistieken.gemiddelde(waarden) als waarden anders 0, “mediaan”: statistieken.median(waarden) als waarden anders 0, “stdev”: statistieken.stdev(waarden) als len(waarden) > 1 anders 0, “min”: min(waarden) als waarden anders 0, “max”: max(waarden) als waarden anders 0 } # Anomalieën identificeren met behulp van de z-score anomalieën = [] voor metric_name, statistieken in metrics_by_service.items(): als stats[“stdev”] > 0: # Vermijd deling door nul z_score = (stats[“max”] – stats[“mean”]) / stats[“stdev”] als z_score > 2: # Meer dan 2 standaarddeviaties anomalieën.append({ “metric”: metric_name, “z_score”: z_score, “severity”: “high” als z_score > 3 anders “medium” }) return { “summary”: ai_summary, “anomalies”: anomalies, “impacted_services”: list(services), “recommendation”: ai_recommendation }

Code 3. Incidentanalyse, anomaliedetectie en inferentiemethode

Integratie van MCP met observatieplatforms kan het beheer en de interpretatie van complexe telemetriegegevens verbeteren. De potentiële voordelen zijn onder andere:

• Snellere detectie van anomalieën, wat resulteert in een kortere minimale detectietijd (MTTD) en minimale oplostijd (MTTR).
• Eenvoudigere identificatie van de grondoorzaken van problemen.
• Minder ruis en minder onbruikbare meldingen, waardoor er minder meldingsmoeheid is en de productiviteit van ontwikkelaars toeneemt.
• Minder onderbrekingen en contextwisselingen tijdens het oplossen van incidenten, wat resulteert in een verbeterde operationele efficiëntie voor een engineeringteam.

Hier zijn enkele belangrijke inzichten uit dit project die teams kunnen helpen met hun observatiestrategie.

• Contextuele metagegevens moeten vroeg in het telemetriegeneratieproces worden opgenomen om latere correlatie te vergemakkelijken.
• Gestructureerde data-interfaces Maak API-gestuurde, gestructureerde querylagen om telemetrie toegankelijker te maken.
• Contextbewuste AI richt de analyse op contextrijke gegevens om de nauwkeurigheid en relevantie te verbeteren.
• Contextverrijking en AI-methoden moeten regelmatig worden verfijnd met behulp van praktische operationele feedback.

De combinatie van gestructureerde datapijplijnen en AI biedt enorme mogelijkheden voor observatie. We kunnen enorme hoeveelheden telemetriedata omzetten in bruikbare inzichten door gebruik te maken van gestructureerde protocollen zoals MCP en AI-gestuurde analyses, wat resulteert in proactieve in plaats van reactieve systemen. Lumigo identificeert drie pijlers van observatie – logs , metrics en traces – die essentieel zijn. Zonder integratie zijn engineers gedwongen om handmatig uiteenlopende databronnen te correleren, wat de respons op incidenten vertraagt.

De manier waarop we telemetrie genereren, vereist structurele veranderingen en analytische technieken om betekenis te ontlenen.

Pronnoy Goswami is een AI- en datawetenschapper met meer dan tien jaar ervaring in het vakgebied.