import io.opentelemetry.api.OpenTelemetry;
import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.sdk.OpenTelemetrySdk;
import io.opentelemetry.sdk.profiling.ProfilingExtension;
import io.opentelemetry.sdk.profiling.config.ProfilingConfig;
import io.opentelemetry.sdk.resources.Resource;
import io.opentelemetry.sdk.trace.SdkTracerProvider;
import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor;
import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporter;
import io.opentelemetry.semconv.resource.attributes.ResourceAttributes;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.Random;

/**
 * Sample Java 24 service with Loom virtual threads and OpenTelemetry 1.20 profiling enabled.
 * Deliberate CPU-bound leak included for demonstration purposes.
 */
public class Java24ProfilingDemo {
    private static final int VIRTUAL_THREAD_COUNT = 1000;
    private static final int CPU_LEAK_THREAD_COUNT = 5;
    private static final AtomicInteger requestCounter = new AtomicInteger(0);
    private static final Random random = new Random();

    public static void main(String[] args) {
        // 1. Initialize OpenTelemetry SDK with profiling extension
        OpenTelemetry openTelemetry = initializeOpenTelemetry();

        // 2. Create virtual thread executor (Java 24 Loom feature)
        ExecutorService virtualExecutor = Executors.newVirtualThreadPerTaskExecutor();
        ExecutorService platformExecutor = Executors.newFixedThreadPool(CPU_LEAK_THREAD_COUNT);

        try {
            // Start deliberate CPU leak threads for profiling demo
            for (int i = 0; i < CPU_LEAK_THREAD_COUNT; i++) {
                platformExecutor.submit(() -> runCpuLeakTask());
            }

            // Start virtual thread workload (simulated HTTP requests)
            for (int i = 0; i < VIRTUAL_THREAD_COUNT; i++) {
                int requestId = i;
                virtualExecutor.submit(() -> handleSimulatedRequest(requestId, openTelemetry));
            }

            // Keep main thread alive for 1 hour to allow profiling collection
            TimeUnit.HOURS.sleep(1);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println(\"Main thread interrupted: \" + e.getMessage());
        } catch (Exception e) {
            System.err.println(\"Fatal service error: \" + e.getMessage());
            e.printStackTrace();
            System.exit(1);
        } finally {
            // Clean up executors
            shutdownExecutor(virtualExecutor, \"Virtual Thread Executor\");
            shutdownExecutor(platformExecutor, \"Platform Thread Executor\");
        }
    }

    /**
     * Initializes OpenTelemetry 1.20 SDK with profiling extension enabled.
     * Configures OTLP export to Pyroscope-compatible endpoint.
     */
    private static OpenTelemetry initializeOpenTelemetry() {
        try {
            // Configure resource attributes (service name required for Pyroscope labeling)
            Resource resource = Resource.getDefault()
                    .merge(Resource.create(Attributes.of(
                            ResourceAttributes.SERVICE_NAME, \"java24-profiling-demo\",
                            ResourceAttributes.SERVICE_VERSION, \"1.0.0\",
                            ResourceAttributes.DEPLOYMENT_ENVIRONMENT, \"production\"
                    )));

            // Enable OpenTelemetry profiling extension (new in OTel 1.20)
            ProfilingConfig profilingConfig = ProfilingConfig.builder()
                    .setEnabled(true)
                    .setSamplingIntervalMs(10) // 10ms sampling for high resolution
                    .setIncludeLoomVirtualThreads(true) // Java 24 Loom support
                    .setIncludeGraalJitCode(true) // Java 24 Graal JIT support
                    .build();

            // Configure OTLP trace exporter to send data to Pyroscope
            OtlpGrpcSpanExporter spanExporter = OtlpGrpcSpanExporter.builder()
                    .setEndpoint(\"http://localhost:4317\") // Pyroscope OTLP gRPC endpoint
                    .setTimeout(5, TimeUnit.SECONDS)
                    .build();

            // Build SDK with profiling extension and trace exporter
            return OpenTelemetrySdk.builder()
                    .setTracerProvider(SdkTracerProvider.builder()
                            .addSpanProcessor(SimpleSpanProcessor.create(spanExporter))
                            .setResource(resource)
                            .build())
                    .addTracerProviderCustomizer((tracerProvider, config) -> 
                            tracerProvider.addSpanProcessor(SimpleSpanProcessor.create(spanExporter)))
                    .addExtension(ProfilingExtension.create(profilingConfig))
                    .build();
        } catch (Exception e) {
            System.err.println(\"Failed to initialize OpenTelemetry: \" + e.getMessage());
            throw new RuntimeException(\"OTel initialization failed\", e);
        }
    }

    /**
     * Simulates an HTTP request handled by a Loom virtual thread.
     */
    private static void handleSimulatedRequest(int requestId, OpenTelemetry openTelemetry) {
        try {
            var tracer = openTelemetry.getTracer(\"request-handler\");
            var span = tracer.spanBuilder(\"simulated-request\")
                    .setAttribute(\"request.id\", requestId)
                    .startSpan();

            // Simulate variable latency (10-500ms)
            TimeUnit.MILLISECONDS.sleep(random.nextInt(490) + 10);
            requestCounter.incrementAndGet();

            span.end();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println(\"Request \" + requestId + \" interrupted\");
        } catch (Exception e) {
            System.err.println(\"Request \" + requestId + \" failed: \" + e.getMessage());
        }
    }

    /**
     * Deliberate CPU-bound leak task (infinite loop with no sleep) for profiling demo.
     */
    private static void runCpuLeakTask() {
        System.out.println(\"Starting CPU leak thread: \" + Thread.currentThread().getName());
        long counter = 0;
        while (true) {
            // Busy loop to consume CPU (intentional leak)
            counter++;
            if (counter % 1_000_000_000 == 0) {
                System.out.println(\"CPU leak thread iteration: \" + counter);
            }
        }
    }

    /**
     * Gracefully shuts down an executor service with timeout.
     */
    private static void shutdownExecutor(ExecutorService executor, String name) {
        executor.shutdown();
        try {
            if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
                executor.shutdownNow();
                System.err.println(name + \" did not terminate in time, forcing shutdown\");
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

# Docker Compose 3.8 configuration for Java 24 profiling stack
# Includes Pyroscope 1.0, OpenTelemetry Collector 0.90, and sample Java 24 service
version: '3.8'

services:
  # Pyroscope 1.0 GA server - stores and visualizes profiling data
  pyroscope:
    image: pyroscope/pyroscope:1.0.0
    container_name: pyroscope-server
    ports:
      - \"4040:4040\"   # Pyroscope UI
      - \"4317:4317\"   # OTLP gRPC endpoint (Java service sends data here)
      - \"4318:4318\"   # OTLP HTTP endpoint
    volumes:
      - pyroscope-data:/var/lib/pyroscope
    command:
      - \"server\"
      - \"--config.file=/etc/pyroscope/pyroscope.yml\"
    configs:
      - source: pyroscope-config
        target: /etc/pyroscope/pyroscope.yml
    healthcheck:
      test: [\"CMD\", \"curl\", \"-f\", \"http://localhost:4040/health\"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped

  # OpenTelemetry Collector - forwards OTel data to Pyroscope
  otel-collector:
    image: otel/opentelemetry-collector-contrib:0.90.0
    container_name: otel-collector
    ports:
      - \"55679:55679\" # Collector metrics
    volumes:
      - ./otel-collector-config.yml:/etc/otel/config.yml
    command: [\"--config\", \"/etc/otel/config.yml\"]
    depends_on:
      pyroscope:
        condition: service_healthy
    restart: unless-stopped

  # Sample Java 24 service with Loom virtual threads
  java-service:
    build:
      context: .
      dockerfile: Dockerfile.java24
    container_name: java24-demo-service
    environment:
      - OTEL_EXPORTER_OTLP_ENDPOINT=http://otel-collector:4317
      - OTEL_SERVICE_NAME=java24-profiling-demo
      - OTEL_RESOURCE_ATTRIBUTES=service.version=1.0.0,deployment.environment=production
      - JAVA_OPTS=-XX:+EnableGraalJIT -XX:+UseLoomVirtualThreads
    depends_on:
      otel-collector:
        condition: service_started
    restart: unless-stopped

  # Load generator to simulate traffic (optional, for demo purposes)
  load-generator:
    image: curlimages/curl:8.5.0
    container_name: load-generator
    command: >
      sh -c \"
        while true; do
          curl -s http://java-service:8080/health > /dev/null;
          sleep 0.1;
        done
      \"
    depends_on:
      java-service:
        condition: service_started
    restart: unless-stopped

configs:
  pyroscope-config:
    content: |
      # Pyroscope 1.0 configuration
      server:
        http:
          listen-addr: \"0.0.0.0:4040\"
      storage:
        # Local filesystem storage (swap to S3/GCS for production)
        filesystem:
          dir: \"/var/lib/pyroscope\"
          retention: \"720h\" # 30 days retention
      otlp:
        # Enable OTLP ingestion for OpenTelemetry profiling data
        enable-ingest: true
        ingest:
          # Accept profiling data from OTel 1.20+
          profiling:
            enabled: true
            sample-rate: 1.0 # Ingest 100% of samples
      logging:
        level: \"info\"

volumes:
  pyroscope-data:
    driver: local

# Dockerfile for Java 24 profiling demo service
# Uses Eclipse Temurin 24 GA JDK with Loom and Graal JIT enabled
ARG JAVA_VERSION=24.0.0_1
FROM eclipse-temurin:${JAVA_VERSION}-jdk-alpine as builder

# Install build dependencies
RUN apk add --no-cache curl git

# Copy project source code
WORKDIR /app
COPY . .

# Build the Java service (using Maven 3.9.6)
RUN curl -fsSL https://archive.apache.org/dist/maven/maven-3/3.9.6/binaries/apache-maven-3.9.6-bin.tar.gz | tar xz -C /opt/
ENV PATH=\"/opt/apache-maven-3.9.6/bin:${PATH}\"
RUN mvn clean package -DskipTests -q

# Runtime stage: minimal Alpine image
FROM eclipse-temurin:${JAVA_VERSION}-jre-alpine

# Install OpenTelemetry 1.20 Java agent (profiling extension included)
RUN curl -fsSL https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/download/v1.20.0/opentelemetry-javaagent.jar -o /opt/opentelemetry-javaagent.jar

# Copy built JAR from builder stage
COPY --from=builder /app/target/java24-profiling-demo-1.0.0.jar /opt/app.jar

# Create non-root user for security
RUN addgroup -S java-group && adduser -S java-user -G java-group
USER java-user

WORKDIR /opt

# JVM configuration for Java 24
# - Enable Graal JIT (default in Java 24, but explicit here)
# - Enable Loom virtual threads (default in Java 24)
# - Set max heap to 512MB for demo purposes
ENV JAVA_OPTS=\"-XX:+EnableGraalJIT -XX:+UseLoomVirtualThreads -Xmx512m -XX:MaxRAMPercentage=75\"

# OTel agent configuration
ENV OTEL_JAVAAGENT_ENABLED=true
ENV OTEL_METRICS_EXPORTER=none
ENV OTEL_LOGS_EXPORTER=none
ENV OTEL_PROFILING_ENABLED=true
ENV OTEL_PROFILING_SAMPLING_INTERVAL_MS=10
ENV OTEL_PROFILING_INCLUDE_LOOM_THREADS=true

# Expose port for simulated HTTP requests (if adding a web server)
EXPOSE 8080

# Health check to verify service is running
HEALTHCHECK --interval=10s --timeout=5s --retries=3 \
  CMD curl -f http://localhost:8080/health || exit 1

# Entrypoint: run the service with OTel agent attached
ENTRYPOINT [\"sh\", \"-c\", \"java $JAVA_OPTS -javaagent:/opt/opentelemetry-javaagent.jar -jar /opt/app.jar\"]

// Snippet: Enable Loom virtual thread profiling in OTel 1.20
ProfilingConfig profilingConfig = ProfilingConfig.builder()
        .setEnabled(true)
        .setSamplingIntervalMs(10)
        .setIncludeLoomVirtualThreads(true) // Critical for Java 24 Loom support
        .build();

// Snippet: Adjust sampling interval for IO-bound workloads
ProfilingConfig profilingConfig = ProfilingConfig.builder()
        .setEnabled(true)
        .setSamplingIntervalMs(50) // 50ms sampling for IO-bound REST APIs
        .setIncludeLoomVirtualThreads(true)
        .build();

# Snippet: Grafana datasource config for Pyroscope 1.0
apiVersion: 1
datasources:
  - name: Pyroscope
    type: pyroscope
    url: http://pyroscope-server:4040
    access: proxy
    isDefault: false
    editable: true
    jsonData:
      enableProfiling: true
      supportedProfileTypes:
        - cpu
        - memory
        - goroutine

java24-pyroscope-profiling/
├── src/
│   └── main/
│       └── java/
│           └── com/
│               └── demo/
│                   └── Java24ProfilingDemo.java  # Main service code
├── Dockerfile.java24                              # Java 24 service Dockerfile
├── docker-compose.yml                             # Full stack configuration
├── otel-collector-config.yml                      # OTel Collector config
├── pyroscope.yml                                  # Pyroscope 1.0 config
├── pom.xml                                        # Maven build file
└── README.md                                      # Setup instructions