performance-concurrency-advisor

Identify throughput and latency bottlenecks in Kotlin Spring services using metrics, traces, and SQL plans.

302|22|Updated Feb 12, 2026
One-click install
npx skills add https://github.com/JetBrains/skills --skill performance-concurrency-advisor-jetbrains
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: performance-concurrency-advisor
Source: https://github.com/JetBrains/skills/tree/main/performance-concurrency-advisor
Command: npx skills add https://github.com/JetBrains/skills --skill performance-concurrency-advisor-jetbrains

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Helps engineering teams diagnose the true bottleneck in Kotlin + Spring services by correlating latency, throughput, traces, and resource signals rather than relying on generic tips.

Core Features & Use Cases

  • Identify the bottleneck causing latency spikes and saturation across service boundaries.
  • Recommend minimal, high-impact changes that improve end-to-end performance while preserving correctness.
  • Use cases include slow endpoints, thread-pool contention, and blocking in reactive paths, supported by evidence-driven validation.

Quick Start

Provide a performance issue description to start analysis and obtain an evidence-driven optimization plan.

Frequently Asked Questions about performance-concurrency-advisor

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I identify the bottleneck causing latency spikes in my Kotlin Spring service?

To identify the bottleneck causing latency spikes in a Kotlin Spring service, correlate latency and throughput metrics with traces and resource signals. This reveals whether thread-pool contention, slow endpoints, or blocking in reactive paths is the true limiting factor.

Why does thread-pool contention happen and how do I diagnose it using traces?

Thread-pool contention happens when concurrent requests exhaust available workers, causing queue waits. Diagnose it by analyzing traces and resource signals to correlate rising latency with pool saturation, confirming the bottleneck rather than relying on generic tips.

What's the best way to fix blocking calls in reactive Spring paths?

The best way to fix blocking in reactive paths is to isolate the blocking operation from the reactive thread pool. Use evidence-driven analysis of traces and metrics to locate the synchronous block, then offload it to a dedicated scheduler to restore throughput.

Can I use SQL execution plans to guide performance optimization of slow endpoints?

Yes, you can use SQL execution plans to guide performance optimization of slow endpoints. Correlating SQL plans with trace data helps pinpoint database-level bottlenecks and validates whether query tuning will improve end-to-end service latency.

What tradeoffs should I consider when optimizing throughput in a Spring service?

When optimizing throughput in a Spring service, consider tradeoffs between increased resource utilization and system stability. Evidence-driven analysis helps evaluate recommended changes, ensuring that improvements to throughput and latency preserve correctness.

How do I verify that a performance optimization change actually improved throughput?

To verify a performance optimization change improved throughput, re-evaluate the same metrics, traces, and resource signals used during diagnosis. This structured validation confirms that the bottleneck is resolved without introducing new contention.