Jaeger

Term 3 · Sep-Nov · 2 projects

• Benchmarking the AI Assistant's MCP Tools and Skills

  LFX Mentorship · Listed in the official cohort

  @jkowallSource IssueLFX portal

  Jaeger's AI assistant analyzes distributed traces through two layers: an MCP server exposing tools that fetch trace data (span details, critical paths, service topology), and a Skills framework — declarative Markdown files that carry domain expertise and narrate when and how to use those tools. Both layers were designed by intuition. We have no empirical evidence for how tool shape and Skill wording change an LLM's reasoning trajectory. This program builds a repeatable evaluation harness so those choices can be A/B tested against deterministic fault scenarios and scored on trajectory metrics rather than prose quality: - Call error rate — did the model produce valid tool parameters? - Steps to evidence — how many calls before the root cause was in hand? - Context bloat — how much raw JSON did the tools push into the window? - Root-cause accuracy — did it land on the seeded fault, without hallucinating? The scenarios are deliberately *trace-solvable*: faults whose cause is fully deducible from spans and span-derived metrics (Jaeger's SPM API), requiring no application logs. Isolating that class of incident is itself part of the research. Prior art to draw on: the OpenTelemetry Demo's feature flags (cartFailure, productCatalogFailure, …) for reproducible incidents; RCA benchmarks such as RCA100, Cloud-OpsBench, OpenRCA and RCAEval for methodology; trajectory-level tool-use evaluations that score intermediate steps rather than final text; and open-source LLM evaluation platforms (Opik, Arize Phoenix, Langfuse) to run and score the loops locally. The technical architecture is the mentee's to propose. Existing work: jaegertracing/jaeger#8440 (Skills framework) and the Jaeger MCP server.

  • Go
  • Python or TypeScript
  • distributed tracing concepts
  • LLM tool use / function calling
  • prompt engineering
  • agentic evaluation

• OpenTelemetry-Native Query and State Layers Migration

  LFX Mentorship · Listed in the official cohort

  @parshipcySource IssueLFX portal

  Jaeger UI is two-thirds through three interlocking migrations at different stages. This program finishes all three and deletes what they replaced. The OpenTelemetry-native move stopped at a deliberate decision point: the UI speaks OTEL vocabulary throughout but obtains it by wrapping the legacy Jaeger model in a facade, and while service discovery and search run on /api/v3/, loading a trace still goes over the legacy endpoint and is reshaped in the browser. The state migration is nearly done, largely via community contributions: Redux has given up traces, search results, services, config, and dependencies. One part is not more of the same: the trace timeline dual-writes to Redux and Zustand, because analytics tracking is a Redux middleware keyed on the old action types, so tracking must move before the old slice can go. The target architecture is designed but not built. The pivotal step is loading a trace natively over /api/v3/. Earlier integrations consumed small, flat messages where a generated schema was cheap. A full trace is the first payload that pulls the entire OTLP model into the query layer: nested resourceSpans/scopeSpans, the recursive AnyValue union behind every attribute, events, links, status. Whether that model is generated and validated at the boundary or hand-written is the central judgement. The wire format is its own research task: Jaeger serialises this route differently from a naive protobuf-to-JSON reading, so a parser that guesses wrong passes its fixtures but fails on a real server. Performance is a hard constraint — traces run to 80,000 spans. Everything is gated on it: once traces arrive as OTLP, the facade, the legacy transformer, the legacy types, and the backend's v1 HTTP endpoints lose their reason to exist. Several contributors already have work open here; refereeing competing approaches and shepherding their PRs to merge is part of the program, and a merged PR the mentee helped land counts as a deliverable met. Deliverables and design docs are in the upstream issue.

  • TypeScript
  • React
  • refactoring a large codebase without regressing it
  • TanStack Query
  • Zustand
  • Zod
  • +5

Term 2 · Jun-Aug · 2 projects

• AI-Powered Trace Analysis: Phase 2 - Self-Service "Skills" Framework

  LFX Mentorship · Listed in the official cohort

  @jkowallSource IssueLFX portal

  Jaeger is the industry-standard platform for distributed tracing. As microservice architectures grow complex, finding root causes in massive trace data becomes increasingly difficult. While Phase 1 of this initiative established a baseline AI assistant for natural language search, the system currently relies on hard-coded capabilities. This project (Phase 2\) aims to transform the Jaeger AI agent from a static chatbot into an extensible, user-programmable platform. The primary objective is to implement a "Self-Service Skills" framework, architecturally similar to "Claude Code Skills." This will allow end-users to teach the Jaeger AI new debugging workflows (e.g., "Analyze Critical Path" or "Detect N+1 Queries") by simply adding configuration files containing system prompts and logic rules, without needing to recompile the Jaeger binary. The applicant will build this extension within the Jaeger v2 (OpenTelemetry-based) architecture, utilizing LangChainGo to orchestrate interactions with Language Models (SLMs/LLMs). This project bridges the gap between generic AI reasoning and domain-specific observability expertise.

  • Languages: Strong proficiency in Go (Golang) is required. Experience with TypeScript/React is highly recommended.
  • AI/LLM: Familiarity with LLM concepts (Prompt Engineering
  • RAG
  • Function Calling) and frameworks like LangChain.
  • Domain Knowledge: Basic understanding of distributed systems
  • observability
  • +1

• Jaeger for GenAI Observability: Specialized Trace Visualization

  LFX Mentorship · Listed in the official cohort

  @yurishkuroSource IssueLFX portal

  Distributed tracing is essential for GenAI observability, but observing AI Agents differs fundamentally from observing microservices. While microservice traces focus on network latency and error codes, AI traces focus on the "reasoning process." The current Jaeger UI displays traces in a standard waterfall timeline, making it difficult to distinguish between logical "Tool Calls" and technical operations, and nearly impossible to read multi-paragraph prompts or view generated images. This project aims to transform the Jaeger UI into a first-class GenAI observability tool. When Jaeger detects a trace containing GenAI-specific metadata (following OpenTelemetry semantic conventions), it should automatically adapt its presentation to prioritize the "Agentic Flow."

  • React
  • TypeScript
  • Ant Design components
  • OpenTelemetry Semantic Conventions (specifically for GenAI)
  • basic knowledge of LLM application patterns (prompting
  • RAG
  • +1

Term 1 · Mar-May · 2 projects

• AI-Powered Trace Analysis with Local LLM Support

  LFX Mentorship · Listed in the official cohort

  @jkowallSource IssueLFX portal

  Jaeger is a widely used distributed tracing platform. This project aims to integrate Small Language Models (SLMs) and Large Language Models (LLMs) into the Jaeger ecosystem to provide intelligent trace analysis. Key features include natural language search mapping (mapping English queries to Jaeger's internal search parameters), contextual analysis, and summarization ("Explain this Span" or "Explain this trace"). The project involves backend integration using Go and LangChainGo, and frontend integration within the Jaeger React UI.

  • Backend: Strong Go (Golang) experience. Architecture: Understanding of OpenTelemetry Collector architecture. AI/LLM: Familiarity with LangChain and prompt engineering for SLMs. Frontend: React.js experience.

• Upgrading Core Routing and State Management in Jaeger UI

  LFX Mentorship · Listed in the official cohort

  @yurishkuroSource IssueLFX portal

  This project focuses on modernizing the Jaeger-UI by upgrading its foundational routing and state management libraries. The primary goals are to migrate from legacy react-router patterns to React Router v7 and replace the deprecated history package and older Redux integration patterns with modern standards like redux-first-history. This refactoring will improve long-term maintainability, enhance performance, and simplify the code for one of the industry's most critical observability tools.

  • JavaScript/TypeScript & React: Deep familiarity with hooks and component lifecycles. State Management: Experience with Redux. Routing Knowledge: Understanding of SPAs and browser history APIs. Testing: Experience with React Testing Library or similar.

Term 3 · Sep-Nov · 1 project

• Next-Generation Jaeger Demo with OpenTelemetry and OpenSearch (2025 Term 3)

  LFX Mentorship · Listed in the official cohort

  @jkowallSource IssueLFX portal

  This project will create a Kubernetes deployment for the full stack: the OpenTelemetry Demo application, the Jaeger backend components (Collector, Query), and OpenSearch as a storage backend. The environment will be automatically redeployed weekly to ensure it is always fresh and to solve the problem of data retention. The entire stack will be hosted on a managed Kubernetes cluster (Oracle Kubernetes Engine) within an Oracle Cloud environment generously donated to the project.

  • Kubernetes
  • Cloud
  • Security
  • Monitoring

Term 2 · Jun-Aug · 2 projects

• Jaeger demo on Kubernetes

  LFX Mentorship · Listed in the official cohort

  @jkowallSource IssueLFX portal

  Jaeger is an open-source, distributed tracing platform designed to monitor and troubleshoot microservices-based systems. We provide an easy getting started guide using docker compose, but we would also like to run a live demo that people can access directly from the Jaeger website. This project aims to create a Kubernetes deployment for the Jaeger demo, including the Jaeger backend and the UI, HotROD demo app, and the Service Performance Monitoring setup, so that users can try out the project in action and we can use this for various events to promote the project. This should be something which automatically deploys the new versions when they are released. The data in the demo environment should either be a rolling buffer or purged daily. It might even be a good idea to just recreate the environment daily which might solve both problems at once. This can be determined by the mentee. We currently have access to an Oracle Cloud environment where this can be stood up for “dev” and “prod” as managed kubernetes clusters.

  • Kubernetes
  • Cloud
  • Security
  • Monitoring

• Upgrade Jaeger-UI to React v19

  LFX Mentorship · Listed in the official cohort

  @yurishkuroSource IssueLFX portal

  Jaeger is an open-source, distributed tracing platform designed to monitor and troubleshoot microservices-based systems. Jaeger-UI is the web UI for Jaeger, built with React. The current version of React used by Jaeger-UI is v18. This project aims to upgrade Jaeger-UI to React v19, in order to stay up to date with the dependencies.

  • Javascript
  • React
  • HTML
  • CSS
  • Web development
  • UI/UX design
  • +1

Term 1 · Mar-May · 2 projects

• Jaeger: Upgrade Storage Backends to V2 Storage API

  LFX Mentorship · Listed in the official cohort

  @yurishkuroSource IssueLFX portal

  Jaeger is an open-source, distributed tracing platform designed to monitor and troubleshoot microservices-based systems. A critical component of Jaeger is its storage backends, where traces captured by Jaeger are stored. With the release of Jaeger v2 last year we introduced a new, more efficient Storage API v2. However, the existing backend implementations in Jaeger are still using v1 API that is only wrapped in the v2 adapter, which prevents them from benefiting from the new capabilities such as batch writes and result streaming. The objective of this project is to upgrade some (or all) backend implementations to use the Storage API v2 natively. Please refer to the upstream issue for more details.

  • Go
  • scripting
  • CI/CD
  • familiarity with Elasticsearch/Cassandra a plus but not required.

• Upgrade charts and graphs in Jaeger UI

  LFX Mentorship · Listed in the official cohort

  @yurishkuroSource IssueLFX portal

  Jaeger is an open-source, distributed tracing platform designed to monitor and troubleshoot microservices-based systems. Jaeger UI pioneered many new visualizations for analyzing distributed traces. However, over time, it accumulated views that utilize different and sometimes deprecated viz libraries. The objective is to standardize charting / graphing libraries used in Jaeger UI, upgrade their dependencies, and add new visualization features. Please refer to the upstream issue for more details.

  • Javascript
  • Typescript
  • React
  • NPM
  • Vite.js

Term 3 · Sep-Nov · 2 projects

• Jaeger v2 Helm Chart

  LFX Mentorship · Listed in the official cohort

  @yurishkuroSource IssueLFX portal

  Currently, Jaeger v1 has an official Helm chart ( but there isn't one yet for Jaeger v2. The goal of this project is to develop a comprehensive Helm chart for Jaeger v2 that allows for easy deployment and management of Jaeger v2 components in Kubernetes environments. This chart should provide flexibility in configuration, support various deployment scenarios, and integrate well with the new architecture of Jaeger v2. More details in the upstream issue.

  • Go
  • scripting
  • kubernetes
  • helm
  • CI/CD

• Jaeger v2 Kubernetes Operator

  LFX Mentorship · Listed in the official cohort

  @yurishkuroSource IssueLFX portal

  Jaeger-v1 has its own Kubernetes Operator ( which deploys Jaeger components according to the deployment strategy as well as the database or datastore. The goal of this project is to develop a new operator for Jaeger-v2 that achieves feature parity with the v1 operator while introducing improvements and new capabilities. This new operator will leverage the OpenTelemetry operator for Jaeger-v2 deployment while maintaining and enhancing the storage management features from the v1 operator. More details in the upstream issue.

  • Go
  • scripting
  • kubernetes
  • operator framework
  • CI/CD

Term 2 · Jun-Aug · 3 projects

• Jaeger-V2 Kafka-based architecture

  LFX Mentorship · Listed in the official cohort

  @yurishkuroSource IssueLFX portal

  Jaeger is a distributed tracing platform. Jaeger V2 is a major new version where we rebase all Jaeger backend components (agent, collector, ingester, and query) on top of the OpenTelemetry Collector. The goal is to implement a deployment mode (supported in Jaeger-v1) that uses Kafka as an intermediate buffer for spans between collector and ingester. It should use the latest version of ibm/sarama driver (related issue) and support both original Jaeger formats as well as OpenTelemetry OTLP. It may be possible to utilize the Kafka exporter/receiver from OTEL contrib.

  • Go
  • scripting
  • CI/CD

• Jaeger-V2 Observability and Healthchecks

  LFX Mentorship · Listed in the official cohort

  @yurishkuroSource IssueLFX portal

  Jaeger is a distributed tracing platform. Jaeger V2 is a major new version where we rebase all Jaeger backend components (agent, collector, ingester, and query) on top of the OpenTelemetry Collector. (1) Currently jaeger-v2 components are initialized without observability clients. We need to instantiate appropriate logging, tracing, and metrics clients and pass them to the components. The existing code uses internal metrics API, which needs to be bridged to OTEL metrics to minimize code changes. (2) Jaeger-v1 components can report their readiness using an internal health check API that is connected to the healthcheck endpoint on the admin port. We need to implement similar capability in Jaeger-v2.

  • Go
  • scripting
  • CI/CD

• Jaeger-V2 Service Performance Monitoring

  LFX Mentorship · Listed in the official cohort

  @yurishkuroSource IssueLFX portal

  Jaeger is a distributed tracing platform. Jaeger V2 is a major new version where we rebase all Jaeger backend components (agent, collector, ingester, and query) on top of the OpenTelemetry Collector. Jaeger-v1 implements a functionality known as SPM, but it requires a separately running OpenTelemetry Collector to produce metrics out of spans using SpanMetrics Connector. Since Jaeger-v2 is built on top of OTEL Collector, we can run SpanMetrics Connector directly in the Jaeger binary and simplify the setup for the users.

  • Go
  • scripting
  • CI/CD

Term 1 · Mar-May · 3 projects

• Jaeger-V2 Adaptive Sampling

  LFX Mentorship · Listed in the official cohort

  @yurishkuroSource IssueLFX portal

  Jaeger is a distributed tracing platform. Jaeger V2 is a major new version where we rebase all Jaeger backend components (agent, collector, ingester, and query) on top of the OpenTelemetry Collector. Jaeger-v1 collector can serve sampling configuration to SDKs, and allows either static configuration (with hot reload) or adaptive sampling that continuously re-calculates the desired sampling probabilities. We need to enable all these capabilities in jaeger-v2.

  • Go
  • scripting
  • CI/CD

• Jaeger-V2 Observability

  LFX Mentorship · Listed in the official cohort

  @yurishkuroSource IssueLFX portal

  Jaeger is a distributed tracing platform. Jaeger V2 is a major new version where we rebase all Jaeger backend components (agent, collector, ingester, and query) on top of the OpenTelemetry Collector. Currently jaeger-v2 components are initialized without observability clients. We need to instantiate appropriate logging, tracing, and metrics clients and pass them to the components. The existing code uses internal metrics API, which needs to be bridged to OTEL metrics to minimize code changes.

  • Go
  • scripting
  • CI/CD

• Jaeger-V2 Storage Backends

  LFX Mentorship · Listed in the official cohort

  @yurishkuroSource IssueLFX portal

  Jaeger is a distributed tracing platform. Jaeger V2 is a major new version where we rebase all Jaeger backend components (agent, collector, ingester, and query) on top of the OpenTelemetry Collector. Currently only memory storage is wired in v2, we need to add Elasticsearch, Opensearch, Cassandra, Badger.

  • Go
  • scripting
  • CI/CD

Term 3 · Sep-Nov · 3 projects

• Build official support in Jaeger for Elasticsearch 8

  LFX Mentorship · Listed in the official cohort

  @yurishkuroSource IssueLFX portal

  Jaeger has always supported Elasticsearch (ES) as an official backend. Unfortunately, the Go driver we are using, olivere/elastic, does not support ESv8 and not planning to release any new versions. Despite the licensing changes, Elasticsearch remains a popular choice and v8 support question often comes up. In this project we want to add official support for ESv8. However, we also want to take this opportunity to do a better alignment with the OpenTelemetry Collector, which already has an ESv8 exporter, perhaps we can use it directly and minimize the amount of code.

  • Go
  • Elasticsearch

• Combine three distinct graph views in Jaeger UI into one

  LFX Mentorship · Listed in the official cohort

  @yurishkuroSource IssueLFX portal

  Jaeger UI provides several views to visualize service dependencies, also known as service topology maps. However, these views are using different drawing libraries, resulting in very different look & feel and inconsistent experience. One of the views is using a plexus library that was purposely built as part of Jaeger UI that provides rich capabilities for displaying graphs, which may be a good candidate for the other views.

  • Javascript
  • Typescript
  • NPM
  • Yarn
  • Vite.js
  • web worker

• Upgrade Jaeger UI to the latest version of React.js

  LFX Mentorship · Listed in the official cohort

  @yurishkuroSource IssueLFX portal

  Jaeger UI is built on React. While we are seemingly already on v18.x of React, the upgrade was not done across the board and some other dependencies are still lagging behind, e.g. "@types/react": "16.8.7". It's also blocking upgrades of other dependencies. This project is likely to involve a substantial amount of code contribution, as certain upgrade require fixing the code to use the new APIs, and sometimes we may run into dependencies that are EOL and need to be replaced altogether.

  • Javascript
  • Typescript
  • NPM
  • Yarn
  • Vite.js

Term 2 · Jun-Aug · 2 projects

• Implement Critical Path analysis

  LFX Mentorship · Listed in the official cohort

  @yurishkuroSource IssueLFX portal

  Jaeger ( is a popular platform for distributed tracing. Critical path analysis is an important tool in the latency investigations. This project aims to add support for critical path analysis to Jaeger UI.

  • Javascript
  • Typescript
  • Go

• Upgrade Jaeger's internal telemetry to OpenTelemetry

  LFX Mentorship · Listed in the official cohort

  @yurishkuroSource IssueLFX portal

  historically, the Jaeger backend used the OpenTracing API, with Jaeger's own Go SDK jaeger-client-go, for instrumenting its own internals for distributed tracing. Since Jaeger's SDKs have been deprecated, we want to upgrade the Jaeger backend to use the OpenTelemetry tracing API and SDK directly.

  • Go