MACRO NEPAL
Honeycomb.io Beeline for Java: Complete Guide
awiskar acharya
November 26, 2025
12:54 pm

Introduction to Honeycomb Beeline

Honeycomb Beeline is a lightweight instrumentation library that makes it easy to collect and send observability data to Honeycomb.io. It provides automatic instrumentation for common Java frameworks and simplifies adding custom telemetry to your applications.

System Architecture Overview

Honeycomb Beeline Pipeline ├── Automatic Instrumentation │ ├ - HTTP Servers (Servlet, Spring MVC) │ ├ - HTTP Clients (OkHttp, Apache HttpClient) │ ├ - Database Calls (JDBC) │ ├ - Messaging (JMS, Kafka) │ └ - Async Processing ├── Custom Instrumentation │ ├ - Business Metrics │ ├ - Custom Spans │ ├ - Trace Context Propagation │ └ - Log Correlation ├── Data Enrichment │ ├ - Global Fields │ ├ - Dynamic Sampling │ └ - Custom Processors └── Honeycomb Backend ├ - Trace Visualization ├ - Query Interface ├ - Trigger Alerts └ - Data Analysis

Core Implementation

1. Maven Dependencies

<properties> <honeycomb.beeline.version>1.4.0</honeycomb.beeline.version> <opentelemetry.version>1.28.0</opentelemetry.version> <spring.boot.version>2.7.0</spring.boot.version> </properties> <dependencies> <!-- Honeycomb Beeline --> <dependency> <groupId>io.honeycomb.beeline</groupId> <artifactId>beeline</artifactId> <version>${honeycomb.beeline.version}</version> </dependency> <!-- Beeline Auto-Instrumentation --> <dependency> <groupId>io.honeycomb.beeline</groupId> <artifactId>beeline-spring-boot-starter</artifactId> <version>${honeycomb.beeline.version}</version> </dependency> <dependency> <groupId>io.honeycomb.beeline</groupId> <artifactId>beeline-servlet</artifactId> <version>${honeycomb.beeline.version}</version> </dependency> <!-- OpenTelemetry (Beeline uses OTel under the hood) --> <dependency> <groupId>io.opentelemetry</groupId> <artifactId>opentelemetry-api</artifactId> <version>${opentelemetry.version}</version> </dependency> <!-- Spring Boot --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>${spring.boot.version}</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-webflux</artifactId> <version>${spring.boot.version}</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> <version>${spring.boot.version}</version> </dependency> <!-- Database --> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <scope>runtime</scope> </dependency> <!-- HTTP Client --> <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpclient</artifactId> <version>4.5.14</version> </dependency> </dependencies>

2. Configuration Setup

import io.honeycomb.beeline.autoconfigure.BeelineAutoConfiguration; import io.honeycomb.beeline.tracing.Beeline; import io.honeycomb.beeline.tracing.Span; import io.honeycomb.beeline.tracing.Tracer; import io.honeycomb.beeline.tracing.Tracing; import io.honeycomb.beeline.tracing.propagation.Propagation; import io.honeycomb.beeline.tracing.sampling.Sampling; import io.honeycomb.libhoney.*; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import java.util.HashMap; import java.util.Map; @Configuration public class HoneycombConfig { @Value("${honeycomb.api.key:}") private String honeycombApiKey; @Value("${honeycomb.dataset:my-java-service}") private String honeycombDataset; @Value("${honeycomb.service.name:order-service}") private String serviceName; @Bean public Beeline beeline() { // Configure Honeycomb client final HoneyClient honeyClient = LibHoney.create( Options.builder() .setWriteKey(honeycombApiKey) .setDataset(honeycombDataset) .setApiHost("https://api.honeycomb.io") // or your Honeycomb endpoint .build() ); // Configure Beeline with global fields final Beeline beeline = new Beeline( honeyClient, Tracing.createTracer( Propagation.createFactory(), Sampling.alwaysSampler(), serviceName ) ); // Add global fields to all events final Map<String, Object> globalFields = new HashMap<>(); globalFields.put("environment", System.getenv().getOrDefault("ENVIRONMENT", "development")); globalFields.put("service.version", System.getenv().getOrDefault("SERVICE_VERSION", "1.0.0")); globalFields.put("deployment.region", System.getenv().getOrDefault("DEPLOYMENT_REGION", "us-east-1")); honeyClient.addGlobalFields(globalFields); return beeline; } @Bean public Tracer tracer(Beeline beeline) { return beeline.getTracer(); } }

3. Application Properties

# application.yml honeycomb: api-key: ${HONEYCOMB_API_KEY:your-api-key-here} dataset: ${HONEYCOMB_DATASET:my-java-service} service: name: ${SERVICE_NAME:order-service} # Beeline Configuration beeline: enabled: true # Sampling configuration sampler: enabled: true sample-rate: 1 # 100% sampling in development # HTTP instrumentation http: include-request-headers: "User-Agent,Content-Type,Accept" include-response-headers: "Content-Type,Content-Length" # SQL instrumentation sql: enabled: true include-query: true # Logging correlation logging: pattern: level: "%5p [trace_id=%X{trace_id},span_id=%X{span_id}]" management: endpoints: web: exposure: include: health,info,metrics,prometheus

4. Spring Boot Auto-Instrumentation

import io.honeycomb.beeline.autoconfigure.BeelineProperties; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.web.servlet.config.annotation.InterceptorRegistry; import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; @Configuration @EnableConfigurationProperties(BeelineProperties.class) public class BeelineAutoConfig implements WebMvcConfigurer { private final Beeline beeline; public BeelineAutoConfig(Beeline beeline) { this.beeline = beeline; } @Override public void addInterceptors(InterceptorRegistry registry) { // Beeline automatically adds interceptors for Spring MVC } @Bean public BeelineHttpServletFilter beelineHttpServletFilter() { return new BeelineHttpServletFilter(beeline); } }

5. Custom Instrumentation Service

import io.honeycomb.beeline.tracing.Beeline; import io.honeycomb.beeline.tracing.Span; import io.honeycomb.beeline.tracing.Tracer; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.stereotype.Service; import java.util.HashMap; import java.util.Map; import java.util.concurrent.CompletableFuture; @Service public class HoneycombInstrumentationService { private static final Logger LOGGER = LoggerFactory.getLogger(HoneycombInstrumentationService.class); private final Beeline beeline; private final Tracer tracer; public HoneycombInstrumentationService(Beeline beeline) { this.beeline = beeline; this.tracer = beeline.getTracer(); } /** * Start a custom span for business operations */ public Span startBusinessSpan(String operationName) { return tracer.startSpan(operationName) .addField("span.type", "business_operation") .addField("service.name", "order-service"); } /** * Instrument a runnable operation with tracing */ public void instrumentOperation(String operationName, Runnable operation) { Span span = startBusinessSpan(operationName); try { operation.run(); span.addField("operation.success", true); } catch (Exception e) { span.addField("operation.success", false); span.addField("error.message", e.getMessage()); throw e; } finally { span.close(); } } /** * Instrument a callable operation with tracing */ public <T> T instrumentOperation(String operationName, Callable<T> operation) { Span span = startBusinessSpan(operationName); try { T result = operation.call(); span.addField("operation.success", true); span.addField("result.type", result.getClass().getSimpleName()); return result; } catch (Exception e) { span.addField("operation.success", false); span.addField("error.message", e.getMessage()); throw new RuntimeException(e); } finally { span.close(); } } /** * Add custom fields to current span */ public void addField(String key, Object value) { Span currentSpan = tracer.getActiveSpan(); if (currentSpan != null) { currentSpan.addField(key, value); } } /** * Record business metrics */ public void recordBusinessMetric(String metricName, double value, Map<String, Object> dimensions) { Span span = tracer.startSpan("business.metric") .addField("metric.name", metricName) .addField("metric.value", value) .addField("metric.type", "gauge"); if (dimensions != null) { dimensions.forEach(span::addField); } span.close(); } /** * Record timing information */ public void recordTiming(String operation, long durationMs) { Span span = tracer.startSpan("timing.measurement") .addField("operation", operation) .addField("duration_ms", durationMs) .addField("measurement.type", "timing"); span.close(); } /** * Async operation instrumentation */ public <T> CompletableFuture<T> instrumentAsyncOperation( String operationName, Supplier<CompletableFuture<T>> asyncOperation) { // Capture current trace context Map<String, String> traceContext = tracer.getActiveSpan().getTraceContext(); Span parentSpan = tracer.startSpan(operationName + ".async") .addField("operation.type", "async") .addField("async.trigger", "true"); return asyncOperation.get() .whenComplete((result, throwable) -> { // Restore trace context in async thread try (Span childSpan = tracer.startChildSpan(parentSpan, operationName + ".completion")) { childSpan.addField("async.completed", true); if (throwable != null) { childSpan.addField("async.success", false); childSpan.addField("error.message", throwable.getMessage()); } else { childSpan.addField("async.success", true); if (result != null) { childSpan.addField("result.present", true); } } } parentSpan.close(); }); } /** * Database query instrumentation */ public void instrumentQuery(String queryType, String table, Runnable query) { Span span = tracer.startSpan("database.query") .addField("db.system", "postgresql") .addField("db.operation", queryType) .addField("db.collection", table) .addField("span.type", "database"); long startTime = System.currentTimeMillis(); try { query.run(); long duration = System.currentTimeMillis() - startTime; span.addField("db.duration_ms", duration); span.addField("db.success", true); } catch (Exception e) { span.addField("db.success", false); span.addField("db.error", e.getMessage()); throw e; } finally { span.close(); } } /** * External service call instrumentation */ public <T> T instrumentExternalCall(String serviceName, String endpoint, Supplier<T> call) { Span span = tracer.startSpan("external.service.call") .addField("service.name", serviceName) .addField("service.endpoint", endpoint) .addField("span.type", "http_client"); long startTime = System.currentTimeMillis(); try { T result = call.get(); long duration = System.currentTimeMillis() - startTime; span.addField("http.duration_ms", duration); span.addField("http.success", true); span.addField("http.status_code", 200); // Assuming success return result; } catch (Exception e) { long duration = System.currentTimeMillis() - startTime; span.addField("http.duration_ms", duration); span.addField("http.success", false); span.addField("http.error", e.getMessage()); throw e; } finally { span.close(); } } /** * Add user context to traces */ public void addUserContext(String userId, String userRole) { Span currentSpan = tracer.getActiveSpan(); if (currentSpan != null) { currentSpan.addField("user.id", userId); currentSpan.addField("user.role", userRole); currentSpan.addField("user.authenticated", true); } } /** * Add request context to traces */ public void addRequestContext(String requestId, String clientIp, String userAgent) { Span currentSpan = tracer.getActiveSpan(); if (currentSpan != null) { currentSpan.addField("request.id", requestId); currentSpan.addField("client.ip", clientIp); currentSpan.addField("user_agent", userAgent); } } }

6. Instrumented REST Controller

import io.honeycomb.beeline.tracing.Span; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*; import java.util.List; import java.util.Map; import java.util.concurrent.CompletableFuture; @RestController @RequestMapping("/api/orders") public class OrderController { private static final Logger LOGGER = LoggerFactory.getLogger(OrderController.class); private final OrderService orderService; private final PaymentService paymentService; private final HoneycombInstrumentationService instrumentation; public OrderController(OrderService orderService, PaymentService paymentService, HoneycombInstrumentationService instrumentation) { this.orderService = orderService; this.paymentService = paymentService; this.instrumentation = instrumentation; } @PostMapping public ResponseEntity<Order> createOrder(@RequestBody OrderRequest request) { LOGGER.info("Creating order for customer: {}", request.getCustomerId()); // Add user context to trace instrumentation.addUserContext(request.getCustomerId(), "customer"); instrumentation.addField("order.amount", request.getAmount()); instrumentation.addField("order.items.count", request.getItems().size()); return instrumentation.instrumentOperation("order.creation", () -> { Order order = orderService.createOrder(request); // Instrument payment processing instrumentation.instrumentExternalCall("payment-service", "/api/payments", () -> paymentService.processPayment(order)); LOGGER.info("Order created successfully: {}", order.getId()); return ResponseEntity.ok(order); }); } @GetMapping("/{orderId}") public ResponseEntity<Order> getOrder(@PathVariable String orderId) { LOGGER.debug("Fetching order: {}", orderId); instrumentation.addField("order.id", orderId); return instrumentation.instrumentOperation("order.retrieval", () -> { Order order = orderService.getOrder(orderId); if (order == null) { instrumentation.addField("order.found", false); return ResponseEntity.notFound().build(); } instrumentation.addField("order.found", true); instrumentation.addField("order.status", order.getStatus()); return ResponseEntity.ok(order); }); } @GetMapping("/customer/{customerId}") public ResponseEntity<List<Order>> getCustomerOrders(@PathVariable String customerId, @RequestParam(defaultValue = "0") int page, @RequestParam(defaultValue = "20") int size) { instrumentation.addUserContext(customerId, "customer"); instrumentation.addField("pagination.page", page); instrumentation.addField("pagination.size", size); return instrumentation.instrumentOperation("customer.orders.retrieval", () -> { List<Order> orders = orderService.getOrdersByCustomer(customerId, page, size); instrumentation.addField("orders.count", orders.size()); instrumentation.recordBusinessMetric("customer.orders.count", orders.size(), Map.of("customer.id", customerId)); return ResponseEntity.ok(orders); }); } @PostMapping("/{orderId}/cancel") public ResponseEntity<Order> cancelOrder(@PathVariable String orderId) { LOGGER.info("Cancelling order: {}", orderId); instrumentation.addField("order.id", orderId); return instrumentation.instrumentOperation("order.cancellation", () -> { Order order = orderService.cancelOrder(orderId); // Async notification instrumentation.instrumentAsyncOperation("order.cancellation.notification", () -> orderService.notifyCancellationAsync(order)); instrumentation.recordBusinessMetric("order.cancelled", 1, Map.of("order.id", orderId, "reason", "user_requested")); return ResponseEntity.ok(order); }); } @GetMapping("/{orderId}/analytics") public CompletableFuture<ResponseEntity<OrderAnalytics>> getOrderAnalytics(@PathVariable String orderId) { LOGGER.debug("Fetching analytics for order: {}", orderId); instrumentation.addField("order.id", orderId); return instrumentation.instrumentAsyncOperation("order.analytics.computation", () -> orderService.computeOrderAnalyticsAsync(orderId)) .thenApply(ResponseEntity::ok); } @PutMapping("/{orderId}/status") public ResponseEntity<Order> updateOrderStatus(@PathVariable String orderId, @RequestBody StatusUpdate update) { LOGGER.info("Updating order status: {} -> {}", orderId, update.getStatus()); instrumentation.addField("order.id", orderId); instrumentation.addField("status.old", update.getPreviousStatus()); instrumentation.addField("status.new", update.getNewStatus()); return instrumentation.instrumentOperation("order.status.update", () -> { long startTime = System.currentTimeMillis(); Order order = orderService.updateOrderStatus(orderId, update); long duration = System.currentTimeMillis() - startTime; instrumentation.recordTiming("order.status.update", duration); // Record status change metric instrumentation.recordBusinessMetric("order.status.change", 1, Map.of("from_status", update.getPreviousStatus(), "to_status", update.getNewStatus(), "order.id", orderId)); return ResponseEntity.ok(order); }); } }

7. Database Instrumentation

import org.springframework.stereotype.Repository; import org.springframework.beans.factory.annotation.Autowired; import javax.persistence.EntityManager; import javax.persistence.Query; import java.util.List; @Repository public class InstrumentedOrderRepository { private final EntityManager entityManager; private final HoneycombInstrumentationService instrumentation; public InstrumentedOrderRepository(EntityManager entityManager, HoneycombInstrumentationService instrumentation) { this.entityManager = entityManager; this.instrumentation = instrumentation; } public Order findById(String orderId) { return instrumentation.instrumentOperation("database.order.find_by_id", () -> { instrumentation.instrumentQuery("SELECT", "orders", () -> LOGGER.debug("Executing find by ID query for order: {}", orderId)); return entityManager.find(Order.class, orderId); }); } public List<Order> findByCustomerId(String customerId, int page, int size) { return instrumentation.instrumentOperation("database.order.find_by_customer", () -> { instrumentation.instrumentQuery("SELECT", "orders", () -> LOGGER.debug("Finding orders for customer: {}", customerId)); Query query = entityManager.createQuery( "SELECT o FROM Order o WHERE o.customerId = :customerId ORDER BY o.createdAt DESC"); query.setParameter("customerId", customerId); query.setFirstResult(page * size); query.setMaxResults(size); return query.getResultList(); }); } public Order save(Order order) { return instrumentation.instrumentOperation("database.order.save", () -> { String operation = order.getId() == null ? "INSERT" : "UPDATE"; instrumentation.instrumentQuery(operation, "orders", () -> LOGGER.debug("Saving order: {}", order.getId())); if (order.getId() == null) { entityManager.persist(order); } else { order = entityManager.merge(order); } return order; }); } public int updateOrderStatus(String orderId, String status) { return instrumentation.instrumentOperation("database.order.update_status", () -> { instrumentation.instrumentQuery("UPDATE", "orders", () -> LOGGER.debug("Updating order status: {} -> {}", orderId, status)); Query query = entityManager.createQuery( "UPDATE Order o SET o.status = :status WHERE o.id = :orderId"); query.setParameter("status", status); query.setParameter("orderId", orderId); return query.executeUpdate(); }); } }

8. HTTP Client Instrumentation

import org.springframework.http.HttpEntity; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpMethod; import org.springframework.http.ResponseEntity; import org.springframework.stereotype.Service; import org.springframework.web.client.RestTemplate; import java.util.Map; @Service public class InstrumentedHttpClient { private final RestTemplate restTemplate; private final HoneycombInstrumentationService instrumentation; public InstrumentedHttpClient(RestTemplate restTemplate, HoneycombInstrumentationService instrumentation) { this.restTemplate = restTemplate; this.instrumentation = instrumentation; } public <T> ResponseEntity<T> executeWithTracing(String serviceName, String url, HttpMethod method, Object requestBody, Class<T> responseType, Map<String, String> headers) { return instrumentation.instrumentExternalCall(serviceName, url, () -> { HttpHeaders httpHeaders = new HttpHeaders(); if (headers != null) { headers.forEach(httpHeaders::add); } HttpEntity<Object> entity = new HttpEntity<>(requestBody, httpHeaders); return restTemplate.exchange(url, method, entity, responseType); }); } public <T> T getWithTracing(String serviceName, String url, Class<T> responseType) { return instrumentation.instrumentExternalCall(serviceName, url, () -> restTemplate.getForObject(url, responseType)); } public <T> T postWithTracing(String serviceName, String url, Object request, Class<T> responseType) { return instrumentation.instrumentExternalCall(serviceName, url, () -> restTemplate.postForObject(url, request, responseType)); } }

9. Custom Sampling Strategies

import io.honeycomb.beeline.tracing.sampling.Sampling; import org.springframework.stereotype.Component; import java.util.function.Function; @Component public class CustomSamplingStrategies { /** * Sample important business operations more frequently */ public static Function<String, Boolean> businessOperationSampler() { return (dataset) -> { // Sample all business operations if (dataset.contains("business") || dataset.contains("order")) { return Sampling.alwaysSampler().sample(dataset); } // Sample 10% of other operations return Math.random() < 0.1; }; } /** * Dynamic sampling based on error rates */ public Function<String, Boolean> adaptiveSampler() { return (dataset) -> { // Increase sampling for error scenarios if (isHighErrorRate(dataset)) { return true; // Sample all events during high error rates } return Sampling.alwaysSampler().sample(dataset); }; } /** * User-based sampling - sample more for important customers */ public Function<String, Boolean> userAwareSampler(String userId) { return (dataset) -> { if (isImportantCustomer(userId)) { return true; // Sample all events for important customers } // Sample 20% for regular customers return Math.random() < 0.2; }; } private boolean isHighErrorRate(String dataset) { // Implement error rate monitoring logic return false; } private boolean isImportantCustomer(String userId) { // Implement customer importance logic return userId.startsWith("VIP_") || userId.endsWith("@enterprise.com"); } }

10. Log Correlation Setup

import org.slf4j.MDC; import org.springframework.stereotype.Component; import javax.servlet.*; import javax.servlet.http.HttpServletRequest; import java.io.IOException; @Component public class LogCorrelationFilter implements Filter { private final Beeline beeline; public LogCorrelationFilter(Beeline beeline) { this.beeline = beeline; } @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { // Extract trace context and add to MDC for logging Span activeSpan = beeline.getTracer().getActiveSpan(); if (activeSpan != null) { Map<String, String> traceContext = activeSpan.getTraceContext(); MDC.put("trace_id", traceContext.get("trace_id")); MDC.put("span_id", traceContext.get("span_id")); } try { chain.doFilter(request, response); } finally { // Clear MDC after request MDC.clear(); } } }

11. Testing Instrumentation

import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.mock.mockito.MockBean; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.*; @SpringBootTest class HoneycombInstrumentationTest { @Autowired private HoneycombInstrumentationService instrumentation; @MockBean private Beeline beeline; @MockBean private Tracer tracer; @MockBean private Span span; @Test void testBusinessOperationInstrumentation() { when(tracer.startSpan(anyString())).thenReturn(span); when(span.addField(anyString(), any())).thenReturn(span); instrumentation.instrumentOperation("test.operation", () -> { // Test operation logic return "result"; }); verify(span).addField("span.type", "business_operation"); verify(span).addField("operation.success", true); verify(span).close(); } @Test void testExternalCallInstrumentation() { when(tracer.startSpan(anyString())).thenReturn(span); when(span.addField(anyString(), any())).thenReturn(span); String result = instrumentation.instrumentExternalCall("test-service", "/api/test", () -> "response"); verify(span).addField("service.name", "test-service"); verify(span).addField("service.endpoint", "/api/test"); verify(span).addField("http.success", true); } }

12. Monitoring and Health Checks

import org.springframework.boot.actuate.health.Health; import org.springframework.boot.actuate.health.HealthIndicator; import org.springframework.stereotype.Component; @Component public class HoneycombHealthIndicator implements HealthIndicator { private final Beeline beeline; public HoneycombHealthIndicator(Beeline beeline) { this.beeline = beeline; } @Override public Health health() { try { // Check if Beeline is properly initialized if (beeline.getTracer() != null) { return Health.up() .withDetail("service", "honeycomb-beeline") .withDetail("status", "connected") .withDetail("tracer", beeline.getTracer().getClass().getSimpleName()) .build(); } else { return Health.down() .withDetail("service", "honeycomb-beeline") .withDetail("error", "Tracer not initialized") .build(); } } catch (Exception e) { return Health.down(e) .withDetail("service", "honeycomb-beeline") .withDetail("error", "Health check failed") .build(); } } }

Best Practices

1. Field Naming Conventions

public class FieldNamingConventions { // Use consistent field naming public static final String SERVICE_NAME = "service.name"; public static final String HTTP_STATUS_CODE = "http.status_code"; public static final String DB_OPERATION = "db.operation"; public static final String ERROR_MESSAGE = "error.message"; // Use dots for hierarchy public static final String METRIC_BUSINESS_ORDER_COUNT = "metric.business.order.count"; public static final String TIMING_DATABASE_QUERY = "timing.database.query"; }

2. Sensitive Data Handling

@Component public class DataSanitization { public Map<String, Object> sanitizeFields(Map<String, Object> fields) { Map<String, Object> sanitized = new HashMap<>(fields); // Remove sensitive fields sanitized.remove("password"); sanitized.remove("credit_card"); sanitized.remove("authorization"); // Hash personal identifiers if (sanitized.containsKey("user_id")) { String userId = (String) sanitized.get("user_id"); sanitized.put("user_id", hashUserId(userId)); } return sanitized; } private String hashUserId(String userId) { return "user_" + Integer.toHexString(userId.hashCode()); } }

3. Performance Optimization

@Component public class PerformanceOptimizations { // Use lazy field evaluation for expensive operations public void addLazyField(Span span, String fieldName, Supplier<Object> valueSupplier) { if (span != null && isSampled(span)) { Object value = valueSupplier.get(); if (value != null) { span.addField(fieldName, value); } } } private boolean isSampled(Span span) { // Check if span is sampled before computing expensive fields return true; // Implementation depends on your sampling strategy } }

Conclusion

This comprehensive Honeycomb Beeline implementation provides:

  • Automatic instrumentation for Spring Boot applications
  • Custom business metrics and tracing
  • Database call instrumentation with timing
  • HTTP client instrumentation for external calls
  • Async operation support with context propagation
  • Custom sampling strategies for cost optimization
  • Log correlation for unified debugging
  • Health monitoring and testing support

Key benefits:

  • Rich observability with detailed traces and metrics
  • Easy integration with Spring Boot auto-configuration
  • Performance optimized with sampling and lazy evaluation
  • Developer friendly with simple instrumentation patterns
  • Production ready with health checks and monitoring

This setup enables comprehensive observability of your Java applications, providing deep insights into performance, errors, and business metrics through Honeycomb.io's powerful analysis platform.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper