Tools & Technologies

A comprehensive overview of the tools, frameworks, and technologies used in this project.

Terminology note: concurrency describes how a runtime handles many in-flight tasks (virtual threads/reactive/goroutines). parallelism describes work happening simultaneously across CPU cores.

Table of Contents

Application Frameworks

Spring Boot 4.0.1

Official Site: https://spring.io/projects/spring-boot

Why We Use It:

Implementation Details:

Thread Models Implemented:

  1. Platform Threads (Traditional)
    • Servlet container thread pool
    • Tomcat connector
    • Blocking I/O model
  2. Virtual Threads (Project Loom)
    • Lightweight threads from Java 21+
    • Simplified async programming
    • Netty connector with virtual thread support
  3. Reactive (WebFlux)
    • Non-blocking I/O
    • Reactor framework
    • Event-loop architecture

Configuration:

server:
  port: 8080
  
spring:
  application:
    name: spring-benchmark
    
management:
  endpoints:
    web:
      exposure:
        include: health,metrics,prometheus

Pros:

Cons:

Quarkus 3.30.7

Official Site: https://quarkus.io/

Why We Use It:

Implementation Details:

Thread Models Implemented:

  1. Platform Threads
    • Traditional blocking I/O
    • Worker thread pool
  2. Virtual Threads
    • Java 21+ virtual threads
    • Seamless async operations
  3. Reactive (Mutiny)
    • Non-blocking reactive streams
    • SmallRye Mutiny API
    • Event-loop based

Configuration:

quarkus.application.name=quarkus-benchmark
quarkus.http.port=8090
quarkus.log.level=INFO

Native Compilation:

# Build native image
mvn package -Pnative

# Size comparison
# JVM JAR: ~200MB
# Native binary: ~50MB

Pros:

Cons:

Go with Fiber (Work in Progress)

Official Site: https://gofiber.io/

Why We’re Adding It:

Implementation Status: 🚧 In Progress

Headline benchmark (18/01/2026): ~52,000 RPS (observability-aligned implementation)

Fairness note: An additional go-simple variant can reach ~120,000 RPS, but it is excluded from headline comparisons because it does not use an equivalent observability setup to the Java services.

Observability Stack

Grafana

Official Site: https://grafana.com/

Purpose: Unified visualization and observability platform

Features Used:

Data Sources Configured:

Dashboards:

Access: http://localhost:3000

Loki

Official Site: https://grafana.com/oss/loki/

Purpose: Log aggregation system

Why Loki:

Configuration Highlights:

ingester:
  chunk_idle_period: 5m
  max_chunk_age: 1h
  
limits_config:
  ingestion_rate_mb: 10
  ingestion_burst_size_mb: 20

Query Examples:

# All logs from service
{service_name="spring-jvm-virtual"}

# Error logs only
{service_name="quarkus-jvm-reactive"} |= "ERROR"

# Request duration parsing
{service_name="spring-jvm-virtual"} | json | duration > 100ms

Tempo

Official Site: https://grafana.com/oss/tempo/

Purpose: Distributed tracing backend

Why Tempo:

Features:

Query Examples:

# Find slow requests
{ duration > 100ms }

# Specific service spans
{ service.name = "spring-jvm-virtual" }

# Error traces
{ status = error }

Mimir

Official Site: https://grafana.com/oss/mimir/

Purpose: Long-term metrics storage (Prometheus-compatible)

Why Mimir:

Metrics Collected:

Query Examples:

# Request rate
rate(http_server_requests_seconds_count[5m])

# P99 latency
histogram_quantile(0.99, http_server_requests_seconds_bucket)

# Heap usage
jvm_memory_used_bytes{area="heap"}

Pyroscope

Official Site: https://grafana.com/oss/pyroscope/

Purpose: Continuous profiling

Why Pyroscope:

Profiling Methods:

  1. Java Agent (JVM only) 
    -javaagent:/opt/pyroscope-agent.jar
    • CPU profiling
    • Allocation profiling
    • Lock contention
  2. eBPF (All services)
    • System-level profiling
    • No instrumentation required
    • Minimal overhead
  3. HTTP Scrape (Pull model)
    • Endpoint-based collection
    • Flexible integration

Profile Types:

Grafana Alloy

Official Site: https://grafana.com/oss/alloy/

Purpose: OpenTelemetry collector and distributor

Why Alloy:

Components Used:

Data Flow:

Services → Alloy → {Loki, Tempo, Mimir, Pyroscope}

Testing & Benchmarking

wrk2

Official Site: https://github.com/giltene/wrk2

Purpose: HTTP benchmarking with constant throughput

Why wrk2 (vs. wrk, ab, etc.):

Key Features:

Typical Usage:

wrk2 -t 8 -c 200 -d 180s -R 80000 --latency http://service:8080/api/cache/key1

Output Metrics:

Comparison to Alternatives:

Tool Type Coordinated Omission Scripting
wrk2 ✅ Fixed rate ✅ Yes ✅ Lua
wrk ❌ Open loop ❌ No ✅ Lua
ab ❌ Open loop ❌ No ❌ No
Gatling ✅ Fixed rate ✅ Yes ✅ Scala

OpenTelemetry

Official Site: https://opentelemetry.io/

Purpose: Standardized telemetry instrumentation

Why OpenTelemetry:

Components:

  1. SDK: Embedded in services
  2. API: Instrumentation interface
  3. Collector: Data pipeline (Alloy)
  4. Protocol: OTLP over gRPC

Instrumentation Methods:

Java Agent (JVM):

-javaagent:/opt/opentelemetry-javaagent.jar

Native Dependency (GraalVM):

<dependency>
    <groupId>io.opentelemetry</groupId>
    <artifactId>opentelemetry-api</artifactId>
</dependency>

Signals Collected:

Infrastructure & Deployment

Docker

Official Site: https://www.docker.com/

Purpose: Containerization platform

Why Docker:

Images Used:

Multi-stage Builds:

# Stage 1: Build
FROM maven:3.9.12-eclipse-temurin-25-noble AS builder
COPY . .
RUN mvn clean package

# Stage 2: Runtime
FROM gcr.io/distroless/java25-debian13:nonroot
COPY --from=builder /target/app.jar /app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

Docker Compose

Official Site: https://docs.docker.com/compose/

Purpose: Multi-container orchestration

Why Docker Compose:

Compose Features Used:

Example:

services:
  spring-jvm-virtual:
    build: ./services/spring/jvm/virtual
    profiles: [SERVICES]
    environment:
      - JAVA_OPTS=-Xmx1g
    deploy:
      resources:
        limits:
          cpus: '4.0'
          memory: 2G

Development Tools

Quality guards (linting / static analysis)

This repository treats code quality tooling as a first-class part of “production readiness”:

Maven

Official Site: https://maven.apache.org/

Purpose: Build automation and dependency management

Why Maven:

Key Plugins:

GraalVM

Official Site: https://www.graalvm.org/

Purpose: High-performance JDK and native compilation

Why GraalVM:

Editions:

Native Image:

native-image \
  -H:+StaticExecutableWithDynamicLibC \
  -H:+ReportExceptionStackTraces \
  -O3 \
  -jar application.jar

Git

Official Site: https://git-scm.com/

Purpose: Version control

Workflow:

Libraries & Dependencies

Caffeine Cache

Official Site: https://github.com/ben-manes/caffeine

Purpose: High-performance Java caching library

Why Caffeine:

Configuration:

Cache<String, String> cache = Caffeine.newBuilder()
    .maximumSize(10000)
    .build();

Reactor (Spring)

Official Site: https://projectreactor.io/

Purpose: Reactive programming library

Features:

Mutiny (Quarkus)

Official Site: https://smallrye.io/smallrye-mutiny/

Purpose: Reactive programming for Quarkus

Features:

Technology Stack Summary

Category Technology Version Purpose / Role
Runtime Java (Eclipse Temurin) 25 JVM runtime for backend services
Runtime GraalVM 25.0.1 Native image compilation
Runtime Go 1.25.6 High-performance Go services
Runtime Node.js 25.4.0 JavaScript runtime for frontend tooling
Framework Spring Boot 4.0.1 Enterprise Java framework
Framework Quarkus 3.30.7 Cloud-native Java framework
Framework React 19.2.3 UI rendering layer
Framework Next.js 16.1.4 Frontend application framework (SSR)
Framework TypeScript 5.9.3 Type-safe frontend development
Library Material UI (MUI) 7.3.7 Component library and theming
Observability Grafana 12.3.1 Dashboards and visualization
Observability Loki 3.6.4 Log aggregation
Observability Tempo 2.9.1 Distributed tracing
Observability Mimir 3.0.2 Long-term metrics storage
Observability Pyroscope 1.18.0 Continuous profiling
Observability Grafana Alloy 1.10.2 Telemetry collection and pipelines
Instrumentation OpenTelemetry SDK 1.58.0 Metrics, traces, and logs instrumentation
Instrumentation OpenTelemetry Distribution 2.24.0 Auto-instrumentation and exporters
Cache Caffeine 3.2.3 High-performance in-memory caching
Container Docker Engine 24+ Container runtime
Orchestration Docker Compose v2 Multi-container orchestration
Orchestration Docker CLI 29.1.5 Image build and lifecycle management
Build Maven 3.9.12 Java build and dependency management
Build npm 11.7.0 Frontend package management
Testing / Load wrk2 Latest HTTP benchmarking and load testing
Testing Vitest 4.0.17 Frontend unit testing
Testing JUnit 5 / 6 JVM unit and integration testing

Further Reading

Official Documentation

Community Resources

Learning Paths

Next: Getting Started Architecture Benchmarking Adding a Service