Custom actuator endpoints in Spring Boot - Performance & Optimization

Performance: Custom actuator endpoints

MEDIUM IMPACT

This affects the server response time and the size of monitoring data sent to clients, impacting backend performance and network load.

Creating a custom actuator endpoint to expose application metrics

Spring Boot

import org.springframework.boot.actuate.endpoint.annotation.Endpoint;
import org.springframework.boot.actuate.endpoint.annotation.ReadOperation;
import java.util.concurrent.atomic.AtomicReference;
import java.util.Map;

@Endpoint(id = "cachedMetrics")
public class CachedMetricsEndpoint {
    private final AtomicReference<Map<String, Object>> cache = new AtomicReference<>();

    public CachedMetricsEndpoint() {
        // Precompute or update cache asynchronously
        cache.set(Map.of("data", "precomputed result"));
    }

    @ReadOperation
    public Map<String, Object> metrics() {
        return cache.get();
    }
}

Precomputes data or caches results to avoid expensive operations during requests, ensuring fast response.

📈 Performance GainResponds instantly without blocking, improving server throughput and reducing latency

Creating a custom actuator endpoint to expose application metrics

Spring Boot

import org.springframework.boot.actuate.endpoint.annotation.Endpoint;
import org.springframework.boot.actuate.endpoint.annotation.ReadOperation;
import java.util.Map;

@Endpoint(id = "heavyMetrics")
public class HeavyMetricsEndpoint {
    @ReadOperation
    public Map<String, Object> metrics() throws InterruptedException {
        // Simulate expensive operation
        Thread.sleep(5000);
        return Map.of("data", "heavy computation result");
    }
}

The endpoint performs a blocking 5-second operation on each request, delaying response and increasing server load.

📉 Performance CostBlocks response for 5 seconds per request, increasing server latency and reducing throughput

Performance Comparison

Pattern	Server Processing	Response Delay	Network Payload	Verdict
Blocking heavy computation in endpoint	High CPU and blocking	5 seconds delay	Small JSON	[X] Bad
Cached or precomputed endpoint data	Minimal CPU, non-blocking	Instant response	Small JSON	[OK] Good

Rendering Pipeline

Custom actuator endpoints run on the server and affect backend processing time before the browser receives data. Slow endpoints delay the server response, increasing time to first byte and overall load time.

→Server Processing

→Network Transfer

⚠️ BottleneckServer Processing when endpoint logic is expensive or blocking

Optimization Tips

1Avoid blocking or long-running operations inside custom actuator endpoints.

2Use caching or asynchronous precomputation to serve data quickly.

3Keep JSON payloads small to reduce network transfer time.

Performance Quiz - 3 Questions

What is the main performance risk of a custom actuator endpoint that performs heavy computation on each request?

A It causes layout shifts on the page

B It increases browser rendering time

C It increases server response time and delays client data reception

D It reduces network bandwidth usage

DevTools: Network

How to check: Open browser DevTools, go to Network tab, trigger the actuator endpoint request, and observe the response time and size.

What to look for: Look for long waiting times (TTFB) indicating slow server processing and check payload size for network impact.

Practice

1. What annotation is used to define a custom actuator endpoint in Spring Boot?

easy

A. @Endpoint

B. @Controller

C. @Service

D. @RestController

Solution

1. Step 1: Understand the purpose of custom actuator endpoints

   Custom actuator endpoints allow you to add your own monitoring or info checks in Spring Boot.

2. Step 2: Identify the correct annotation for defining custom endpoints

   The @Endpoint annotation is specifically designed to mark a class as a custom actuator endpoint.

3. Final Answer:

   @Endpoint -> Option A

4. Quick Check:

   Custom actuator endpoint = @Endpoint [OK]

Hint: Custom actuator endpoints always use @Endpoint annotation [OK]

Common Mistakes:

• Confusing @Endpoint with @Controller
• Using @Service instead of @Endpoint
• Using @RestController which is for REST APIs

2. Which annotation should you use on a method inside a custom actuator endpoint to expose a read-only operation?

easy

A. @WriteOperation

B. @ReadOperation

C. @GetMapping

D. @PostMapping

Solution

1. Step 1: Recall method annotations for custom actuator endpoints

   Custom actuator endpoints use specific annotations to define operations: read or write.

2. Step 2: Match read-only operation annotation

   The @ReadOperation annotation marks a method as a read-only operation accessible via HTTP GET.

3. Final Answer:

   @ReadOperation -> Option B

4. Quick Check:

   Read-only method = @ReadOperation [OK]

Hint: Use @ReadOperation for read-only endpoint methods [OK]

Common Mistakes:

• Using @WriteOperation for read methods
• Confusing @GetMapping with actuator annotations
• Using @PostMapping which is for REST controllers

3. Given this custom endpoint class, what will be the HTTP response body when accessing the endpoint?

@Endpoint(id = "status")
public class StatusEndpoint {
  @ReadOperation
  public String getStatus() {
    return "UP";
  }
}

medium

A. "DOWN"

B. 404 Not Found

C. "UP"

D. 500 Internal Server Error

Solution

1. Step 1: Analyze the custom endpoint class

   The class is annotated with @Endpoint(id = "status") and has a method with @ReadOperation returning "UP".

2. Step 2: Understand the HTTP response from the read operation

   Accessing the actuator endpoint with id "status" triggers the getStatus() method, returning the string "UP" as the response body.

3. Final Answer:

   "UP" -> Option C

4. Quick Check:

   Read operation returns "UP" [OK]

Hint: ReadOperation returns method result as HTTP response body [OK]

Common Mistakes:

• Expecting 404 if endpoint is defined correctly
• Confusing return value with HTTP status code
• Assuming method returns JSON object instead of string

4. Identify the error in this custom actuator endpoint code:

@Endpoint(id = "metrics")
public class MetricsEndpoint {
  @ReadOperation
  public String metrics() {
    return 12345;
  }
}

medium

A. The @ReadOperation annotation is missing

B. The method name must be getMetrics

C. The @Endpoint annotation must be on a method, not class

D. The method declares String return type but returns an int

Solution

1. Step 1: Check method return type consistency

   The method metrics() returns an integer literal 12345 but declares return type String, causing a type mismatch.

2. Step 2: Verify annotations and method naming

   The @ReadOperation annotation is present, and @Endpoint is correctly on the class. Method name can be arbitrary.

3. Final Answer:

   The method declares String return type but returns an int -> Option D

4. Quick Check:

   Return type mismatch causes error [OK]

Hint: Method return type must match declared type [OK]

Common Mistakes:

• Thinking @Endpoint goes on methods
• Assuming method name must follow getter pattern
• Ignoring type mismatch errors

5. You want to create a custom actuator endpoint that accepts a POST request to update a configuration value. Which combination of annotations and method signature is correct? A)

@Endpoint(id = "config")
public class ConfigEndpoint {
  @WriteOperation
  public String updateConfig(String key, String value) {
    // update logic
    return "Updated";
  }
}

B)

@Endpoint(id = "config")
public class ConfigEndpoint {
  @ReadOperation
  public void updateConfig(String key, String value) {
    // update logic
  }
}

C)

@Endpoint(id = "config")
public class ConfigEndpoint {
  @WriteOperation
  public void updateConfig() {
    // update logic
  }
}

D)

@Endpoint(id = "config")
public class ConfigEndpoint {
  @WriteOperation
  public String updateConfig() {
    // update logic
    return "Updated";
  }
}

hard

A. Option A is correct because @WriteOperation supports parameters and returns a response

B. Option B is correct because @ReadOperation can update values

C. Option C is correct because @WriteOperation methods cannot have parameters

D. Option D is correct because @WriteOperation methods should not have parameters

Solution

1. Step 1: Understand @WriteOperation usage

   @WriteOperation marks methods that handle write operations, typically POST, and can accept parameters for input.

2. Step 2: Analyze method signatures and annotations

   The correct combination uses @WriteOperation with String key and String value parameters and returns a String response, which is valid for POST updates. Using @ReadOperation is wrong for update operations. The other snippets lack parameters needed to receive key and value.

3. Final Answer:

   Option A is correct because @WriteOperation supports parameters and returns a response -> Option A

4. Quick Check:

   @WriteOperation with parameters for POST updates [OK]

Hint: Use @WriteOperation with parameters for POST updates [OK]

Common Mistakes:

• Using @ReadOperation for write/update methods
• Omitting parameters needed for update
• Assuming @WriteOperation methods cannot return values