Telemetrie

@Path("/palindrome")
@Produces("application/json")
public class PalindromeResource {
    private final MeterRegistry registry;
    private final LinkedList<String> list = new LinkedList<>();

    public PalindromeResource(MeterRegistry registry) {
        this.registry = registry;
        registry.gaugeCollectionSize("palindrome.list.size", Tags.empty(), list);
    }

    @GET
    @Path("counter/check/{input}")
    public boolean checkPalindromeCounter(@PathParam("input") String input) {
        list.add(input);

        registry.counter("palindrome.counter").increment();
        boolean result = internalCheckPalindrome(input);
        return result;
    }

    @GET
    @Path("timer/check/{input}")
    public boolean checkPalindromeAndTimer(@PathParam("input") String input) {
        list.add(input);

        Timer.Sample sample = Timer.start(registry);
        boolean result = internalCheckPalindrome(input);
        sample.stop(registry.timer("palindrome.timer"));
        return result;
    }

    private boolean internalCheckPalindrome(String input) {
        int left = 0;
        int right = input.length() - 1;

        while (left < right) {
            if (input.charAt(left) != input.charAt(right)) {
                return false;
            }
            left++;
            right--;
        }
        return true;
    }

    @DELETE
    @Path("empty-list")
    public void emptyList() {
        list.clear();
    }
}

mvn package

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - "9090:9090"
    restart: always
    networks:
      - monitoring

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    restart: always
    networks:
      - monitoring

  quarkus:
    build:
      context: ../../../
      dockerfile: ./src/main/docker/Dockerfile.jvm
    container_name: quarkus
    ports:
      - "8080:8080" # Optional, for host access
    restart: always
    networks:
      - monitoring

networks:
  monitoring:
    driver: bridge

<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-opentelemetry</artifactId>
</dependency>
<dependency>
    <groupId>io.opentelemetry.instrumentation</groupId>
    <artifactId>opentelemetry-jdbc</artifactId>
</dependency>

# Enable OpenTelemetry tracing

quarkus.otel.exporter.otlp.endpoint=http://localhost:4317

quarkus.otel.traces.sampler=always_on

quarkus.otel.service.name=quarkus-backend

# For JDBC telemetry
quarkus.datasource.jdbc.telemetry=true

apiVersion: jaegertracing.io/v1
kind: Jaeger
metadata:
  name: simplest

public Uni<Response> sendInvite(@PathParam("electionId") Long electionId) {
Span span = tracer.spanBuilder("sendEmails").startSpan();

        Optional<Election> election = Election.findByIdOptional(electionId);

        if (election.isEmpty()) {
            return Uni.createFrom().item(Response.status(Response.Status.NOT_FOUND).build());
        }

        try (Scope scope = span.makeCurrent()) {

            // Perform email sending logic in a background task
            emailService.sendInvitations(election.get()).subscribe().with(
                    success -> System.out.println("Emails sent successfully"),
                    failure -> System.out.println("Emails could not be sent\n" + failure.toString())
            );
        } finally {
            span.end();
        }

        return Uni.createFrom().item(Response.ok().entity("{\"message\": \"Emails are being sent asynchronously.\"}").build());
    }

docker run -d --name jaeger \
  -e COLLECTOR_ZIPKIN_HTTP_PORT=9411 \
  -p 4317:4317 \
  -p 4318:4318 \
  -p 5775:5775/udp \
  -p 6831:6831/udp \
  -p 6832:6832/udp \
  -p 5778:5778 \
  -p 16686:16686 \
  -p 14268:14268 \
  -p 9411:9411 \
  jaegertracing/all-in-one:1.62.0

minikube start --cpus 15 --memory=8g --driver=docker

kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.16.2/cert-manager.yaml

kubectl create namespace observability (1)

export WORKING_DIR=/tmp/jaeger
export NAMESPACE=observability  # Change if needed

./generate_certs.sh

kubectl create -f https://github.com/jaegertracing/jaeger-operator/releases/download/v1.62.0/jaeger-operator.yaml

kubectl delete secret jaeger-operator-service-cert -n observability
kubectl create secret tls jaeger-operator-service-cert \
  --cert=${WORKING_DIR}/user.jaeger.crt \
  --key=${WORKING_DIR}/user.jaeger.key \
  -n observability

kubectl apply -f .

kubectl apply -f ./jaeger.yaml