Article: Comprehensive Error Monitoring with Raygun in Java Applications
Raygun provides powerful crash reporting and error monitoring capabilities for applications. This article covers comprehensive integration strategies for Java applications with advanced features like error grouping, user tracking, and performance monitoring.
Core Raygun Integration
package com.titliel.raygun;
import com.raygun.raygun4java.RaygunClient;
import com.raygun.raygun4java.messages.RaygunMessage;
import com.raygun.raygun4java.messages.RaygunMessageBuilder;
import com.raygun.raygun4java.messages.RaygunErrorMessage;
import com.raygun.raygun4java.messages.RaygunEnvironmentMessage;
import com.raygun.raygun4java.messages.RaygunRequestMessage;
import com.raygun.raygun4java.messages.RaygunUserInfo;
import com.raygun.raygun4java.messages.RaygunIdentifier;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
/**
* Titliel Raygun Crash Reporter
* Advanced error monitoring with custom grouping and analytics
*/
public class TitlielRaygunReporter {
private final RaygunClient raygunClient;
private final RaygunConfig config;
private final ErrorAnalytics analytics;
private final ExecutorService executorService;
private final LinkedBlockingQueue<ErrorEvent> errorQueue;
private final Map<String, ErrorRateLimiter> rateLimiters;
private volatile boolean shutdown = false;
public TitlielRaygunReporter(String apiKey) {
this.raygunClient = new RaygunClient(apiKey);
this.config = RaygunConfig.getInstance();
this.analytics = new ErrorAnalytics();
this.executorService = Executors.newFixedThreadPool(2);
this.errorQueue = new LinkedBlockingQueue<>(1000);
this.rateLimiters = new ConcurrentHashMap<>();
initialize();
}
private void initialize() {
// Start background error processing
executorService.submit(this::processErrorQueue);
// Start analytics reporting
executorService.submit(this::reportAnalytics);
// Register shutdown hook
Runtime.getRuntime().addShutdownHook(new Thread(this::shutdown));
}
/**
* Report exception with custom data
*/
public void reportError(Throwable throwable, ErrorContext context) {
if (!shouldReportError(throwable, context)) {
return;
}
ErrorEvent errorEvent = new ErrorEvent(throwable, context);
try {
if (!errorQueue.offer(errorEvent, 100, java.util.concurrent.TimeUnit.MILLISECONDS)) {
// Queue full, handle accordingly
handleQueueFull(errorEvent);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
// Fallback to synchronous reporting
reportErrorSync(errorEvent);
}
}
/**
* Report error with custom message and severity
*/
public void reportError(String message, ErrorSeverity severity, ErrorContext context) {
CustomException exception = new CustomException(message);
context.setCustomMessage(message);
context.setSeverity(severity);
reportError(exception, context);
}
/**
* Report handled exception (non-fatal)
*/
public void reportHandledError(Throwable throwable, String feature, Map<String, Object> customData) {
ErrorContext context = new ErrorContext()
.setFeature(feature)
.setCustomData(customData)
.setHandled(true)
.setSeverity(ErrorSeverity.WARNING);
reportError(throwable, context);
}
/**
* Report performance issue as error
*/
public void reportPerformanceIssue(String operation, long duration, long threshold) {
String message = String.format("Performance issue: %s took %dms (threshold: %dms)",
operation, duration, threshold);
PerformanceException exception = new PerformanceException(message);
ErrorContext context = new ErrorContext()
.setFeature("performance")
.setCustomData(Map.of(
"operation", operation,
"duration", duration,
"threshold", threshold,
"type", "performance_issue"
))
.setSeverity(ErrorSeverity.WARNING);
reportError(exception, context);
}
/**
* Track user session for error correlation
*/
public void setUserSession(UserSession session) {
RaygunUserInfo userInfo = new RaygunUserInfo(session.getUserId());
userInfo.setEmail(session.getEmail());
userInfo.setFullName(session.getFullName());
userInfo.setFirstName(session.getFirstName());
userInfo.setUuid(session.getSessionId());
// Add custom user data
Map<String, Object> customData = new HashMap<>();
customData.put("signupDate", session.getSignupDate());
customData.put("accountType", session.getAccountType());
customData.put("lastLogin", session.getLastLogin());
raygunClient.setUserInfo(userInfo);
raygunClient.setCustomData(customData);
}
/**
* Set application version for release tracking
*/
public void setApplicationVersion(String version) {
raygunClient.setVersion(version);
}
/**
* Add custom grouping key for error aggregation
*/
public void setCustomGroupingKey(String key, String value) {
raygunClient.getCustomData().put("groupingKey." + key, value);
}
private void processErrorQueue() {
while (!shutdown || !errorQueue.isEmpty()) {
try {
ErrorEvent errorEvent = errorQueue.poll(100, java.util.concurrent.TimeUnit.MILLISECONDS);
if (errorEvent != null) {
reportErrorSync(errorEvent);
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
}
private void reportErrorSync(ErrorEvent errorEvent) {
try {
RaygunMessage message = buildRaygunMessage(errorEvent);
raygunClient.send(message);
// Update analytics
analytics.recordError(errorEvent);
} catch (Exception e) {
System.err.println("Failed to report error to Raygun: " + e.getMessage());
// Fallback to local logging
logErrorLocally(errorEvent, e);
}
}
private RaygunMessage buildRaygunMessage(ErrorEvent errorEvent) {
RaygunMessageBuilder messageBuilder = RaygunMessageBuilder.New()
.SetEnvironmentDetails(buildEnvironmentMessage())
.SetMachineName(config.getMachineName())
.SetVersion(config.getAppVersion());
// Build error details
RaygunErrorMessage errorMessage = buildErrorMessage(errorEvent.getThrowable());
messageBuilder.SetErrorDetails(errorMessage);
// Add custom data
Map<String, Object> customData = buildCustomData(errorEvent.getContext());
messageBuilder.SetCustomData(customData);
// Add user information
if (errorEvent.getContext().getUser() != null) {
RaygunUserInfo userInfo = buildUserInfo(errorEvent.getContext().getUser());
messageBuilder.SetUserInfo(userInfo);
}
// Add request information if available
if (errorEvent.getContext().getRequest() != null) {
RaygunRequestMessage requestMessage = buildRequestMessage(errorEvent.getContext().getRequest());
messageBuilder.SetRequestDetails(requestMessage);
}
// Set tags
List<String> tags = buildTags(errorEvent);
messageBuilder.SetTags(tags);
return messageBuilder.Build();
}
private RaygunErrorMessage buildErrorMessage(Throwable throwable) {
// Custom error message builder with enhanced stack traces
return new RaygunErrorMessage(throwable) {
@Override
public String getClassName() {
return throwable.getClass().getName();
}
@Override
public String getMessage() {
String customMessage = extractCustomMessage(throwable);
return customMessage != null ? customMessage : throwable.getMessage();
}
};
}
private Map<String, Object> buildCustomData(ErrorContext context) {
Map<String, Object> customData = new HashMap<>();
// Basic context
customData.put("feature", context.getFeature());
customData.put("handled", context.isHandled());
customData.put("severity", context.getSeverity().name());
customData.put("timestamp", new Date());
// Custom data from context
if (context.getCustomData() != null) {
customData.putAll(context.getCustomData());
}
// Application-specific data
customData.put("environment", config.getEnvironment());
customData.put("deployment", config.getDeploymentId());
customData.put("sessionId", context.getSessionId());
// Performance metrics if available
if (context.getPerformanceMetrics() != null) {
customData.put("performance", context.getPerformanceMetrics());
}
return customData;
}
private List<String> buildTags(ErrorEvent errorEvent) {
List<String> tags = new ArrayList<>();
tags.add("environment:" + config.getEnvironment());
tags.add("severity:" + errorEvent.getContext().getSeverity().name());
tags.add("handled:" + errorEvent.getContext().isHandled());
tags.add("feature:" + errorEvent.getContext().getFeature());
// Add error type tags
tags.add("type:" + errorEvent.getThrowable().getClass().getSimpleName());
return tags;
}
private boolean shouldReportError(Throwable throwable, ErrorContext context) {
// Check rate limiting
String rateLimitKey = getRateLimitKey(throwable, context);
ErrorRateLimiter rateLimiter = rateLimiters.computeIfAbsent(rateLimitKey,
k -> new ErrorRateLimiter(config.getMaxErrorsPerMinute()));
if (!rateLimiter.allowRequest()) {
analytics.recordRateLimitedError(throwable, context);
return false;
}
// Check ignored exceptions
if (isIgnoredException(throwable)) {
return false;
}
// Check environment filters
if (!shouldReportInEnvironment()) {
return false;
}
return true;
}
private boolean isIgnoredException(Throwable throwable) {
List<String> ignoredPatterns = config.getIgnoredExceptions();
String exceptionName = throwable.getClass().getName();
return ignoredPatterns.stream()
.anyMatch(pattern -> exceptionName.matches(pattern));
}
private boolean shouldReportInEnvironment() {
String environment = config.getEnvironment();
List<String> reportEnvironments = config.getReportEnvironments();
return reportEnvironments.contains(environment) ||
reportEnvironments.contains("all");
}
private String getRateLimitKey(Throwable throwable, ErrorContext context) {
return throwable.getClass().getName() + ":" + context.getFeature();
}
private void handleQueueFull(ErrorEvent errorEvent) {
// Implement fallback strategy
analytics.recordDroppedError(errorEvent);
if (config.isFallbackLoggingEnabled()) {
logErrorLocally(errorEvent, new Exception("Error queue full"));
}
}
private void logErrorLocally(ErrorEvent errorEvent, Exception reportingError) {
// Log to local file or system logs
System.err.println("Failed to report error to Raygun: " + reportingError.getMessage());
System.err.println("Original error: " + errorEvent.getThrowable().getMessage());
}
private void reportAnalytics() {
while (!shutdown) {
try {
Thread.sleep(60000); // Report every minute
ErrorAnalytics.Snapshot snapshot = analytics.createSnapshot();
reportAnalyticsToRaygun(snapshot);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
}
}
}
private void reportAnalyticsToRaygun(ErrorAnalytics.Snapshot snapshot) {
// Report analytics as custom errors or use Raygun's metrics API
Map<String, Object> analyticsData = new HashMap<>();
analyticsData.put("totalErrors", snapshot.getTotalErrors());
analyticsData.put("uniqueErrors", snapshot.getUniqueErrors());
analyticsData.put("errorRate", snapshot.getErrorRate());
analyticsData.put("topFeatures", snapshot.getTopFeatures(5));
ErrorContext context = new ErrorContext()
.setFeature("analytics")
.setCustomData(analyticsData)
.setHandled(true)
.setSeverity(ErrorSeverity.INFO);
reportError("Error Analytics Report", ErrorSeverity.INFO, context);
}
public void shutdown() {
shutdown = true;
executorService.shutdown();
try {
if (!executorService.awaitTermination(30, java.util.concurrent.TimeUnit.SECONDS)) {
executorService.shutdownNow();
}
} catch (InterruptedException e) {
executorService.shutdownNow();
Thread.currentThread().interrupt();
}
// Process remaining errors
processErrorQueue();
}
// Helper methods for building Raygun messages
private RaygunEnvironmentMessage buildEnvironmentMessage() {
RaygunEnvironmentMessage env = new RaygunEnvironmentMessage();
env.setProcessorCount(Runtime.getRuntime().availableProcessors());
env.setOsVersion(System.getProperty("os.version"));
env.setArchitecture(System.getProperty("os.arch"));
env.setTotalPhysicalMemory(Runtime.getRuntime().totalMemory());
env.setAvailablePhysicalMemory(Runtime.getRuntime().freeMemory());
return env;
}
private RaygunUserInfo buildUserInfo(User user) {
RaygunUserInfo userInfo = new RaygunUserInfo(user.getId());
userInfo.setEmail(user.getEmail());
userInfo.setFullName(user.getFullName());
userInfo.setFirstName(user.getFirstName());
// Add custom user properties
Map<String, Object> customData = new HashMap<>();
customData.put("company", user.getCompany());
customData.put("department", user.getDepartment());
customData.put("role", user.getRole());
userInfo.setCustomData(customData);
return userInfo;
}
private RaygunRequestMessage buildRequestMessage(RequestInfo request) {
RaygunRequestMessage requestMessage = new RaygunRequestMessage();
requestMessage.setHostName(request.getHost());
requestMessage.setUrl(request.getUrl());
requestMessage.setHttpMethod(request.getMethod());
requestMessage.setIpAddress(request.getIpAddress());
requestMessage.setQueryString(request.getQueryParams());
requestMessage.setHeaders(request.getHeaders());
requestMessage.setFormData(request.getFormData());
return requestMessage;
}
private String extractCustomMessage(Throwable throwable) {
if (throwable instanceof CustomException) {
return throwable.getMessage();
}
return null;
}
}
Data Models and Context
package com.titliel.raygun;
import java.util.*;
/**
* Error context with comprehensive metadata
*/
public class ErrorContext {
private String feature;
private boolean handled = false;
private ErrorSeverity severity = ErrorSeverity.ERROR;
private String customMessage;
private Map<String, Object> customData;
private User user;
private RequestInfo request;
private String sessionId;
private Map<String, Object> performanceMetrics;
private Date timestamp;
public ErrorContext() {
this.timestamp = new Date();
this.customData = new HashMap<>();
}
// Fluent builder methods
public ErrorContext setFeature(String feature) {
this.feature = feature;
return this;
}
public ErrorContext setHandled(boolean handled) {
this.handled = handled;
return this;
}
public ErrorContext setSeverity(ErrorSeverity severity) {
this.severity = severity;
return this;
}
public ErrorContext setCustomMessage(String customMessage) {
this.customMessage = customMessage;
return this;
}
public ErrorContext setCustomData(Map<String, Object> customData) {
this.customData = customData;
return this;
}
public ErrorContext setUser(User user) {
this.user = user;
return this;
}
public ErrorContext setRequest(RequestInfo request) {
this.request = request;
return this;
}
public ErrorContext setSessionId(String sessionId) {
this.sessionId = sessionId;
return this;
}
public ErrorContext setPerformanceMetrics(Map<String, Object> performanceMetrics) {
this.performanceMetrics = performanceMetrics;
return this;
}
public ErrorContext addCustomData(String key, Object value) {
if (this.customData == null) {
this.customData = new HashMap<>();
}
this.customData.put(key, value);
return this;
}
// Getters
public String getFeature() { return feature; }
public boolean isHandled() { return handled; }
public ErrorSeverity getSeverity() { return severity; }
public String getCustomMessage() { return customMessage; }
public Map<String, Object> getCustomData() { return Collections.unmodifiableMap(customData); }
public User getUser() { return user; }
public RequestInfo getRequest() { return request; }
public String getSessionId() { return sessionId; }
public Map<String, Object> getPerformanceMetrics() { return performanceMetrics; }
public Date getTimestamp() { return timestamp; }
}
/**
* Error severity levels
*/
public enum ErrorSeverity {
INFO, WARNING, ERROR, CRITICAL
}
/**
* User information for error correlation
*/
public class User {
private final String id;
private String email;
private String fullName;
private String firstName;
private String company;
private String department;
private String role;
public User(String id) {
this.id = id;
}
// Fluent builder methods
public User withEmail(String email) {
this.email = email;
return this;
}
public User withFullName(String fullName) {
this.fullName = fullName;
return this;
}
public User withFirstName(String firstName) {
this.firstName = firstName;
return this;
}
public User withCompany(String company) {
this.company = company;
return this;
}
public User withDepartment(String department) {
this.department = department;
return this;
}
public User withRole(String role) {
this.role = role;
return this;
}
// Getters
public String getId() { return id; }
public String getEmail() { return email; }
public String getFullName() { return fullName; }
public String getFirstName() { return firstName; }
public String getCompany() { return company; }
public String getDepartment() { return department; }
public String getRole() { return role; }
}
/**
* Request information for web errors
*/
public class RequestInfo {
private String host;
private String url;
private String method;
private String ipAddress;
private Map<String, String> queryParams;
private Map<String, String> headers;
private Map<String, String> formData;
// Fluent builder methods
public RequestInfo setHost(String host) {
this.host = host;
return this;
}
public RequestInfo setUrl(String url) {
this.url = url;
return this;
}
public RequestInfo setMethod(String method) {
this.method = method;
return this;
}
public RequestInfo setIpAddress(String ipAddress) {
this.ipAddress = ipAddress;
return this;
}
public RequestInfo setQueryParams(Map<String, String> queryParams) {
this.queryParams = queryParams;
return this;
}
public RequestInfo setHeaders(Map<String, String> headers) {
this.headers = headers;
return this;
}
public RequestInfo setFormData(Map<String, String> formData) {
this.formData = formData;
return this;
}
// Getters
public String getHost() { return host; }
public String getUrl() { return url; }
public String getMethod() { return method; }
public String getIpAddress() { return ipAddress; }
public Map<String, String> getQueryParams() { return queryParams; }
public Map<String, String> getHeaders() { return headers; }
public Map<String, String> getFormData() { return formData; }
}
/**
* User session information
*/
public class UserSession {
private String userId;
private String sessionId;
private String email;
private String fullName;
private String firstName;
private Date signupDate;
private Date lastLogin;
private String accountType;
// Getters and setters
public String getUserId() { return userId; }
public void setUserId(String userId) { this.userId = userId; }
public String getSessionId() { return sessionId; }
public void setSessionId(String sessionId) { this.sessionId = sessionId; }
public String getEmail() { return email; }
public void setEmail(String email) { this.email = email; }
public String getFullName() { return fullName; }
public void setFullName(String fullName) { this.fullName = fullName; }
public String getFirstName() { return firstName; }
public void setFirstName(String firstName) { this.firstName = firstName; }
public Date getSignupDate() { return signupDate; }
public void setSignupDate(Date signupDate) { this.signupDate = signupDate; }
public Date getLastLogin() { return lastLogin; }
public void setLastLogin(Date lastLogin) { this.lastLogin = lastLogin; }
public String getAccountType() { return accountType; }
public void setAccountType(String accountType) { this.accountType = accountType; }
}
/**
* Error event container
*/
class ErrorEvent {
private final Throwable throwable;
private final ErrorContext context;
private final Date timestamp;
public ErrorEvent(Throwable throwable, ErrorContext context) {
this.throwable = throwable;
this.context = context;
this.timestamp = new Date();
}
// Getters
public Throwable getThrowable() { return throwable; }
public ErrorContext getContext() { return context; }
public Date getTimestamp() { return timestamp; }
}
/**
* Custom exception types
*/
class CustomException extends Exception {
public CustomException(String message) {
super(message);
}
public CustomException(String message, Throwable cause) {
super(message, cause);
}
}
class PerformanceException extends Exception {
public PerformanceException(String message) {
super(message);
}
}
Error Analytics and Rate Limiting
package com.titliel.raygun;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
import java.util.stream.Collectors;
/**
* Error analytics and tracking
*/
public class ErrorAnalytics {
private final AtomicLong totalErrors = new AtomicLong(0);
private final AtomicLong rateLimitedErrors = new AtomicLong(0);
private final AtomicLong droppedErrors = new AtomicLong(0);
private final Map<String, ErrorStats> errorStats = new ConcurrentHashMap<>();
private final Map<String, FeatureStats> featureStats = new ConcurrentHashMap<>();
private final long startTime = System.currentTimeMillis();
public void recordError(ErrorEvent errorEvent) {
totalErrors.incrementAndGet();
String errorKey = getErrorKey(errorEvent.getThrowable());
String feature = errorEvent.getContext().getFeature();
// Update error statistics
errorStats.computeIfAbsent(errorKey, k -> new ErrorStats())
.recordError(errorEvent);
// Update feature statistics
featureStats.computeIfAbsent(feature, k -> new FeatureStats())
.recordError(errorEvent);
}
public void recordRateLimitedError(Throwable throwable, ErrorContext context) {
rateLimitedErrors.incrementAndGet();
}
public void recordDroppedError(ErrorEvent errorEvent) {
droppedErrors.incrementAndGet();
}
public Snapshot createSnapshot() {
long currentTime = System.currentTimeMillis();
long runningTime = currentTime - startTime;
Snapshot snapshot = new Snapshot();
snapshot.setTotalErrors(totalErrors.get());
snapshot.setRateLimitedErrors(rateLimitedErrors.get());
snapshot.setDroppedErrors(droppedErrors.get());
snapshot.setRunningTime(runningTime);
snapshot.setErrorRate(calculateErrorRate(runningTime));
snapshot.setUniqueErrors(errorStats.size());
snapshot.setTopFeatures(getTopFeatures(10));
snapshot.setTopErrors(getTopErrors(10));
return snapshot;
}
private double calculateErrorRate(long runningTime) {
double minutes = runningTime / 60000.0;
return minutes > 0 ? totalErrors.get() / minutes : 0.0;
}
private Map<String, Long> getTopFeatures(int count) {
return featureStats.entrySet().stream()
.sorted((e1, e2) -> Long.compare(e2.getValue().getCount(), e1.getValue().getCount()))
.limit(count)
.collect(Collectors.toMap(
Map.Entry::getKey,
e -> e.getValue().getCount()
));
}
private Map<String, Long> getTopErrors(int count) {
return errorStats.entrySet().stream()
.sorted((e1, e2) -> Long.compare(e2.getValue().getCount(), e1.getValue().getCount()))
.limit(count)
.collect(Collectors.toMap(
Map.Entry::getKey,
e -> e.getValue().getCount()
));
}
private String getErrorKey(Throwable throwable) {
return throwable.getClass().getName() + ":" + throwable.getMessage();
}
/**
* Analytics snapshot
*/
public static class Snapshot {
private long totalErrors;
private long rateLimitedErrors;
private long droppedErrors;
private long runningTime;
private double errorRate;
private long uniqueErrors;
private Map<String, Long> topFeatures;
private Map<String, Long> topErrors;
// Getters and setters
public long getTotalErrors() { return totalErrors; }
public void setTotalErrors(long totalErrors) { this.totalErrors = totalErrors; }
public long getRateLimitedErrors() { return rateLimitedErrors; }
public void setRateLimitedErrors(long rateLimitedErrors) { this.rateLimitedErrors = rateLimitedErrors; }
public long getDroppedErrors() { return droppedErrors; }
public void setDroppedErrors(long droppedErrors) { this.droppedErrors = droppedErrors; }
public long getRunningTime() { return runningTime; }
public void setRunningTime(long runningTime) { this.runningTime = runningTime; }
public double getErrorRate() { return errorRate; }
public void setErrorRate(double errorRate) { this.errorRate = errorRate; }
public long getUniqueErrors() { return uniqueErrors; }
public void setUniqueErrors(long uniqueErrors) { this.uniqueErrors = uniqueErrors; }
public Map<String, Long> getTopFeatures() { return topFeatures; }
public void setTopFeatures(Map<String, Long> topFeatures) { this.topFeatures = topFeatures; }
public Map<String, Long> getTopErrors() { return topErrors; }
public void setTopErrors(Map<String, Long> topErrors) { this.topErrors = topErrors; }
public Map<String, Long> getTopFeatures(int count) {
return topFeatures.entrySet().stream()
.sorted(Map.Entry.<String, Long>comparingByValue().reversed())
.limit(count)
.collect(Collectors.toMap(
Map.Entry::getKey,
Map.Entry::getValue
));
}
}
}
/**
* Error statistics
*/
class ErrorStats {
private final AtomicLong count = new AtomicLong(0);
private final AtomicLong lastOccurrence = new AtomicLong(0);
private final Map<String, AtomicLong> severityCounts = new ConcurrentHashMap<>();
public void recordError(ErrorEvent errorEvent) {
count.incrementAndGet();
lastOccurrence.set(System.currentTimeMillis());
String severity = errorEvent.getContext().getSeverity().name();
severityCounts.computeIfAbsent(severity, k -> new AtomicLong(0))
.incrementAndGet();
}
public long getCount() { return count.get(); }
public long getLastOccurrence() { return lastOccurrence.get(); }
public Map<String, Long> getSeverityCounts() {
return severityCounts.entrySet().stream()
.collect(Collectors.toMap(
Map.Entry::getKey,
e -> e.getValue().get()
));
}
}
/**
* Feature-specific statistics
*/
class FeatureStats {
private final AtomicLong count = new AtomicLong(0);
private final AtomicLong errorCount = new AtomicLong(0);
private final AtomicLong warningCount = new AtomicLong(0);
public void recordError(ErrorEvent errorEvent) {
count.incrementAndGet();
switch (errorEvent.getContext().getSeverity()) {
case ERROR, CRITICAL -> errorCount.incrementAndGet();
case WARNING -> warningCount.incrementAndGet();
}
}
public long getCount() { return count.get(); }
public long getErrorCount() { return errorCount.get(); }
public long getWarningCount() { return warningCount.get(); }
public double getErrorRate() {
return count.get() > 0 ? (double) errorCount.get() / count.get() : 0.0;
}
}
/**
* Rate limiting for error reporting
*/
class ErrorRateLimiter {
private final int maxRequestsPerMinute;
private final Queue<Long> requestTimestamps;
public ErrorRateLimiter(int maxRequestsPerMinute) {
this.maxRequestsPerMinute = maxRequestsPerMinute;
this.requestTimestamps = new LinkedList<>();
}
public synchronized boolean allowRequest() {
long currentTime = System.currentTimeMillis();
long oneMinuteAgo = currentTime - 60000;
// Remove old timestamps
while (!requestTimestamps.isEmpty() && requestTimestamps.peek() < oneMinuteAgo) {
requestTimestamps.poll();
}
// Check if under rate limit
if (requestTimestamps.size() < maxRequestsPerMinute) {
requestTimestamps.offer(currentTime);
return true;
}
return false;
}
}
Spring Boot Integration
package com.titliel.raygun.spring;
import com.titliel.raygun.TitlielRaygunReporter;
import com.titliel.raygun.ErrorContext;
import com.titliel.raygun.RequestInfo;
import com.titliel.raygun.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
/**
* Spring Boot integration for Raygun error reporting
*/
@Component
public class RaygunSpringInterceptor implements HandlerInterceptor {
@Autowired
private TitlielRaygunReporter raygunReporter;
private static final ThreadLocal<Long> requestStartTime = new ThreadLocal<>();
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
requestStartTime.set(System.currentTimeMillis());
return true;
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex) {
if (ex != null) {
// Build error context from request
ErrorContext context = buildErrorContext(request, response);
// Report the error
raygunReporter.reportError(ex, context);
}
// Record performance metrics
recordPerformanceMetrics(request, response);
requestStartTime.remove();
}
private ErrorContext buildErrorContext(HttpServletRequest request, HttpServletResponse response) {
RequestInfo requestInfo = new RequestInfo()
.setHost(request.getServerName())
.setUrl(request.getRequestURL().toString())
.setMethod(request.getMethod())
.setIpAddress(getClientIp(request))
.setQueryParams(extractQueryParams(request))
.setHeaders(extractHeaders(request))
.setFormData(extractFormData(request));
return new ErrorContext()
.setFeature("web-request")
.setHandled(false)
.setRequest(requestInfo)
.addCustomData("http.status", response.getStatus())
.addCustomData("http.userAgent", request.getHeader("User-Agent"))
.addCustomData("http.referer", request.getHeader("Referer"))
.addCustomData("session.id", request.getSession(false) != null ?
request.getSession().getId() : "no-session");
}
private void recordPerformanceMetrics(HttpServletRequest request, HttpServletResponse response) {
Long startTime = requestStartTime.get();
if (startTime != null) {
long duration = System.currentTimeMillis() - startTime;
// Report slow requests as performance issues
if (duration > 5000) { // 5 second threshold
Map<String, Object> metrics = new HashMap<>();
metrics.put("duration", duration);
metrics.put("url", request.getRequestURI());
metrics.put("method", request.getMethod());
ErrorContext context = new ErrorContext()
.setFeature("performance")
.setHandled(true)
.setCustomData(metrics);
raygunReporter.reportPerformanceIssue(
request.getMethod() + " " + request.getRequestURI(),
duration, 5000
);
}
}
}
private String getClientIp(HttpServletRequest request) {
String xForwardedFor = request.getHeader("X-Forwarded-For");
if (xForwardedFor != null && !xForwardedFor.isEmpty()) {
return xForwardedFor.split(",")[0].trim();
}
return request.getRemoteAddr();
}
private Map<String, String> extractQueryParams(HttpServletRequest request) {
Map<String, String> params = new HashMap<>();
Enumeration<String> paramNames = request.getParameterNames();
while (paramNames.hasMoreElements()) {
String paramName = paramNames.nextElement();
params.put(paramName, request.getParameter(paramName));
}
return params;
}
private Map<String, String> extractHeaders(HttpServletRequest request) {
Map<String, String> headers = new HashMap<>();
Enumeration<String> headerNames = request.getHeaderNames();
while (headerNames.hasMoreElements()) {
String headerName = headerNames.nextElement();
headers.put(headerName, request.getHeader(headerName));
}
return headers;
}
private Map<String, String> extractFormData(HttpServletRequest request) {
// For POST requests with form data
if ("POST".equalsIgnoreCase(request.getMethod()) &&
request.getContentType() != null &&
request.getContentType().contains("application/x-www-form-urlencoded")) {
return extractQueryParams(request); // Form data is available as parameters
}
return new HashMap<>();
}
}
/**
* Spring configuration for Raygun
*/
package com.titliel.raygun.spring;
import com.titliel.raygun.TitlielRaygunReporter;
import org.springframework.beans.factory.annotation.Value;
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
public class RaygunConfig implements WebMvcConfigurer {
@Value("${raygun.api.key:}")
private String raygunApiKey;
@Value("${raygun.enabled:false}")
private boolean raygunEnabled;
@Bean
public TitlielRaygunReporter raygunReporter() {
if (raygunEnabled && !raygunApiKey.isEmpty()) {
return new TitlielRaygunReporter(raygunApiKey);
}
return null;
}
@Bean
public RaygunSpringInterceptor raygunInterceptor() {
return new RaygunSpringInterceptor();
}
@Override
public void addInterceptors(InterceptorRegistry registry) {
if (raygunEnabled) {
registry.addInterceptor(raygunInterceptor());
}
}
}
Configuration Management
package com.titliel.raygun;
import java.io.InputStream;
import java.util.*;
/**
* Raygun configuration manager
*/
public class RaygunConfig {
private static RaygunConfig instance;
private final Properties properties;
private RaygunConfig() {
this.properties = loadProperties();
}
public static synchronized RaygunConfig getInstance() {
if (instance == null) {
instance = new RaygunConfig();
}
return instance;
}
private Properties loadProperties() {
Properties props = new Properties();
try (InputStream input = getClass().getClassLoader()
.getResourceAsStream("raygun.properties")) {
if (input != null) {
props.load(input);
} else {
setDefaults(props);
}
} catch (Exception e) {
setDefaults(props);
}
return props;
}
private void setDefaults(Properties props) {
props.setProperty("raygun.environment", "development");
props.setProperty("raygun.app.version", "1.0.0");
props.setProperty("raygun.max.errors.per.minute", "100");
props.setProperty("raygun.fallback.logging.enabled", "true");
props.setProperty("raygun.report.environments", "production,staging");
props.setProperty("raygun.ignored.exceptions",
"java.lang.InterruptedException,org.springframework.dao.OptimisticLockingFailureException");
}
// Getters
public String getEnvironment() {
return properties.getProperty("raygun.environment", "development");
}
public String getAppVersion() {
return properties.getProperty("raygun.app.version", "1.0.0");
}
public String getDeploymentId() {
return properties.getProperty("raygun.deployment.id",
System.getenv("DEPLOYMENT_ID"));
}
public String getMachineName() {
return properties.getProperty("raygun.machine.name",
System.getenv("HOSTNAME"));
}
public int getMaxErrorsPerMinute() {
return Integer.parseInt(properties.getProperty("raygun.max.errors.per.minute", "100"));
}
public boolean isFallbackLoggingEnabled() {
return Boolean.parseBoolean(properties.getProperty("raygun.fallback.logging.enabled", "true"));
}
public List<String> getReportEnvironments() {
String environments = properties.getProperty("raygun.report.environments", "production,staging");
return Arrays.asList(environments.split(","));
}
public List<String> getIgnoredExceptions() {
String exceptions = properties.getProperty("raygun.ignored.exceptions", "");
return Arrays.asList(exceptions.split(","));
}
}
Usage Examples
package com.titliel.service;
import com.titliel.raygun.TitlielRaygunReporter;
import com.titliel.raygun.ErrorContext;
import com.titliel.raygun.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.Map;
@Service
public class UserService {
@Autowired
private TitlielRaygunReporter raygunReporter;
public User createUser(User user) {
try {
// Set user context for error tracking
raygunReporter.setUserSession(createUserSession(user));
// Business logic
validateUser(user);
User savedUser = userRepository.save(user);
return savedUser;
} catch (ValidationException e) {
// Report handled validation error
ErrorContext context = new ErrorContext()
.setFeature("user.validation")
.setHandled(true)
.setCustomData(Map.of(
"userId", user.getId(),
"email", user.getEmail(),
"validationRule", e.getRule()
));
raygunReporter.reportHandledError(e, "user-creation", context.getCustomData());
throw e;
} catch (DatabaseException e) {
// Report critical database error
ErrorContext context = new ErrorContext()
.setFeature("user.persistence")
.setHandled(false)
.setCustomData(Map.of(
"userId", user.getId(),
"database", "users-db",
"operation", "insert"
));
raygunReporter.reportError(e, context);
throw e;
}
}
public void processUserBatch(List<User> users) {
long startTime = System.currentTimeMillis();
try {
for (User user : users) {
processUser(user);
}
} catch (Exception e) {
// Report batch processing error with performance context
long duration = System.currentTimeMillis() - startTime;
Map<String, Object> performanceMetrics = new HashMap<>();
performanceMetrics.put("batchSize", users.size());
performanceMetrics.put("processingTime", duration);
performanceMetrics.put("successCount", calculateSuccessCount(users));
ErrorContext context = new ErrorContext()
.setFeature("batch.processing")
.setHandled(true)
.setPerformanceMetrics(performanceMetrics)
.setCustomData(Map.of(
"batchId", UUID.randomUUID().toString(),
"failedUser", getFailedUser(e)
));
raygunReporter.reportHandledError(e, "user-batch", context.getCustomData());
} finally {
// Report performance metrics
long duration = System.currentTimeMillis() - startTime;
if (duration > 30000) { // 30 second threshold
raygunReporter.reportPerformanceIssue(
"processUserBatch", duration, 30000
);
}
}
}
private UserSession createUserSession(User user) {
UserSession session = new UserSession();
session.setUserId(user.getId());
session.setEmail(user.getEmail());
session.setFullName(user.getFullName());
session.setSessionId(UUID.randomUUID().toString());
return session;
}
private void validateUser(User user) {
if (user.getEmail() == null || !user.getEmail().contains("@")) {
throw new ValidationException("Invalid email format", "email_validation");
}
}
// Helper methods
private int calculateSuccessCount(List<User> users) {
// Implementation details
return users.size() - 1; // Example
}
private String getFailedUser(Exception e) {
// Extract failed user from exception
return "unknown";
}
}
/**
* Custom exception for validation
*/
class ValidationException extends RuntimeException {
private final String rule;
public ValidationException(String message, String rule) {
super(message);
this.rule = rule;
}
public String getRule() { return rule; }
}
class DatabaseException extends RuntimeException {
public DatabaseException(String message, Throwable cause) {
super(message, cause);
}
}
Maven Dependencies
<dependencies> <!-- Raygun Java Client --> <dependency> <groupId>com.raygun</groupId> <artifactId>raygun4java</artifactId> <version>2.4.0</version> </dependency> <!-- Spring Boot --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- JSON Processing --> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.15.0</version> </dependency> <!-- Logging --> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-api</artifactId> <version>2.0.7</version> </dependency> </dependencies>
Application Properties
# Raygun Configuration raygun.api.key=your-api-key-here raygun.enabled=true raygun.environment=production raygun.app.version=1.2.0 # Error Reporting Settings raygun.max.errors.per.minute=100 raygun.fallback.logging.enabled=true raygun.report.environments=production,staging # Ignored Exceptions raygun.ignored.exceptions=java.lang.InterruptedException,org.springframework.dao.OptimisticLockingFailureException
Best Practices
1. Error Classification
- Use appropriate severity levels
- Distinguish between handled and unhandled errors
- Group similar errors effectively
2. User Context
- Always set user information for error correlation
- Include relevant user properties
- Maintain session context
3. Performance Monitoring
- Report performance issues as errors
- Include timing and resource metrics
- Set appropriate thresholds
4. Rate Limiting
- Implement error rate limiting
- Monitor dropped error rates
- Adjust limits based on volume
5. Environment Management
- Configure different settings per environment
- Use appropriate API keys
- Monitor error rates across environments
This Titliel Raygun integration provides comprehensive error monitoring with advanced features like performance tracking, user correlation, and intelligent error grouping for enterprise Java applications.
Advanced Java Supply Chain Security, Kubernetes Hardening & Runtime Threat Detection
Sigstore Rekor in Java – https://macronepal.com/blog/sigstore-rekor-in-java/
Explains integrating Sigstore Rekor into Java systems to create a transparent, tamper-proof log of software signatures and metadata for verifying supply chain integrity.
Securing Java Applications with Chainguard Wolfi – https://macronepal.com/blog/securing-java-applications-with-chainguard-wolfi-a-comprehensive-guide/
Explains using Chainguard Wolfi minimal container images to reduce vulnerabilities and secure Java applications with hardened, lightweight runtime environments.
Cosign Image Signing in Java Complete Guide – https://macronepal.com/blog/cosign-image-signing-in-java-complete-guide/
Explains how to digitally sign container images using Cosign in Java-based workflows to ensure authenticity and prevent unauthorized modifications.
Secure Supply Chain Enforcement Kyverno Image Verification for Java Containers – https://macronepal.com/blog/secure-supply-chain-enforcement-kyverno-image-verification-for-java-containers/
Explains enforcing Kubernetes policies with Kyverno to verify container image signatures and ensure only trusted Java container images are deployed.
Pod Security Admission in Java Securing Kubernetes Deployments for JVM Applications – https://macronepal.com/blog/pod-security-admission-in-java-securing-kubernetes-deployments-for-jvm-applications/
Explains Kubernetes Pod Security Admission policies that enforce security rules like restricted privileges and safe configurations for Java workloads.
Securing Java Applications at Runtime Kubernetes Security Context – https://macronepal.com/blog/securing-java-applications-at-runtime-a-guide-to-kubernetes-security-context/
Explains how Kubernetes security contexts control runtime permissions, user IDs, and access rights for Java containers to improve isolation.
Process Anomaly Detection in Java Behavioral Monitoring – https://macronepal.com/blog/process-anomaly-detection-in-java-comprehensive-behavioral-monitoring-2/
Explains detecting abnormal runtime behavior in Java applications to identify potential security threats using process monitoring techniques.
Achieving Security Excellence CIS Benchmark Compliance for Java Applications – https://macronepal.com/blog/achieving-security-excellence-implementing-cis-benchmark-compliance-for-java-applications/
Explains applying CIS security benchmarks to Java environments to standardize hardening and improve overall system security posture.
Process Anomaly Detection in Java Behavioral Monitoring – https://macronepal.com/blog/process-anomaly-detection-in-java-comprehensive-behavioral-monitoring/
Explains behavioral monitoring of Java processes to detect anomalies and improve runtime security through continuous observation and analysis.
JAVA CODE COMPILER