MACRO NEPAL
GC Log Analyzer in Java
awiskar acharya
November 10, 2025
12:42 pm

Project Overview

A comprehensive Garbage Collection log analyzer that parses, analyzes, and provides insights into Java GC behavior. Helps identify memory issues, performance bottlenecks, and optimization opportunities.

Technology Stack

  • Core: Java 17+
  • Parsing: Regex patterns, Java NIO
  • Analysis: Statistical analysis, trend detection
  • Visualization: HTML reports with charts (Chart.js)
  • Concurrency: Parallel processing for large logs
  • Data Structures: Custom time-series analysis

Project Structure

gc-log-analyzer/
├── src/main/java/com/gcanalyzer/
│   ├── parser/
│   ├── model/
│   ├── analyzer/
│   ├── reporter/
│   ├── detector/
│   └── cli/
├── src/main/resources/
│   └── templates/
├── examples/
│   └── gc-logs/
└── config/

Core Implementation

1. Data Models

package com.gcanalyzer.model;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
public class GCLog {
private final String id;
private final String source;
private final LocalDateTime startTime;
private final List<GCEvent> events;
private final Map<String, String> metadata;
private final GCStatistics statistics;
public GCLog(String source) {
this.id = UUID.randomUUID().toString();
this.source = source;
this.startTime = LocalDateTime.now();
this.events = new CopyOnWriteArrayList<>();
this.metadata = new ConcurrentHashMap<>();
this.statistics = new GCStatistics();
}
// Builder pattern
public static class Builder {
private String source;
private List<GCEvent> events = new ArrayList<>();
private Map<String, String> metadata = new HashMap<>();
public Builder source(String source) {
this.source = source;
return this;
}
public Builder addEvent(GCEvent event) {
this.events.add(event);
return this;
}
public Builder addEvents(List<GCEvent> events) {
this.events.addAll(events);
return this;
}
public Builder metadata(String key, String value) {
this.metadata.put(key, value);
return this;
}
public GCLog build() {
GCLog log = new GCLog(source);
log.events.addAll(events);
log.metadata.putAll(metadata);
return log;
}
}
// Getters
public String getId() { return id; }
public String getSource() { return source; }
public LocalDateTime getStartTime() { return startTime; }
public List<GCEvent> getEvents() { return Collections.unmodifiableList(events); }
public Map<String, String> getMetadata() { return Collections.unmodifiableMap(metadata); }
public GCStatistics getStatistics() { return statistics; }
// Utility methods
public void addEvent(GCEvent event) {
events.add(event);
statistics.update(event);
}
public List<GCEvent> getEventsByType(GCEventType type) {
return events.stream()
.filter(event -> event.getType() == type)
.collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
}
public List<GCEvent> getEventsInTimeRange(LocalDateTime start, LocalDateTime end) {
return events.stream()
.filter(event -> !event.getTimestamp().isBefore(start) && 
!event.getTimestamp().isAfter(end))
.collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
}
public Optional<GCEvent> findEventById(String eventId) {
return events.stream()
.filter(event -> event.getId().equals(eventId))
.findFirst();
}
public long getTotalEventsCount() {
return events.size();
}
public long getEventsCountByType(GCEventType type) {
return events.stream()
.filter(event -> event.getType() == type)
.count();
}
@Override
public String toString() {
return String.format("GCLog[source=%s, events=%d, duration=%.2fs]", 
source, events.size(), getDurationSeconds());
}
public double getDurationSeconds() {
if (events.isEmpty()) return 0.0;
LocalDateTime first = events.get(0).getTimestamp();
LocalDateTime last = events.get(events.size() - 1).getTimestamp();
return java.time.Duration.between(first, last).toMillis() / 1000.0;
}
}
public class GCEvent {
private final String id;
private final LocalDateTime timestamp;
private final GCEventType type;
private final String gcName;
private final double duration; // in seconds
private final MemoryUsage before;
private final MemoryUsage after;
private final MemoryUsage total;
private final Map<String, Object> additionalInfo;
public GCEvent(LocalDateTime timestamp, GCEventType type, String gcName, double duration) {
this.id = UUID.randomUUID().toString();
this.timestamp = timestamp;
this.type = type;
this.gcName = gcName;
this.duration = duration;
this.before = new MemoryUsage();
this.after = new MemoryUsage();
this.total = new MemoryUsage();
this.additionalInfo = new HashMap<>();
}
// Builder pattern
public static class Builder {
private LocalDateTime timestamp;
private GCEventType type;
private String gcName;
private double duration;
private MemoryUsage before = new MemoryUsage();
private MemoryUsage after = new MemoryUsage();
private MemoryUsage total = new MemoryUsage();
private Map<String, Object> additionalInfo = new HashMap<>();
public Builder timestamp(LocalDateTime timestamp) {
this.timestamp = timestamp;
return this;
}
public Builder type(GCEventType type) {
this.type = type;
return this;
}
public Builder gcName(String gcName) {
this.gcName = gcName;
return this;
}
public Builder duration(double duration) {
this.duration = duration;
return this;
}
public Builder before(MemoryUsage before) {
this.before = before;
return this;
}
public Builder after(MemoryUsage after) {
this.after = after;
return this;
}
public Builder total(MemoryUsage total) {
this.total = total;
return this;
}
public Builder additionalInfo(String key, Object value) {
this.additionalInfo.put(key, value);
return this;
}
public GCEvent build() {
GCEvent event = new GCEvent(timestamp, type, gcName, duration);
event.before.copyFrom(before);
event.after.copyFrom(after);
event.total.copyFrom(total);
event.additionalInfo.putAll(additionalInfo);
return event;
}
}
// Getters
public String getId() { return id; }
public LocalDateTime getTimestamp() { return timestamp; }
public GCEventType getType() { return type; }
public String getGcName() { return gcName; }
public double getDuration() { return duration; }
public MemoryUsage getBefore() { return before; }
public MemoryUsage getAfter() { return after; }
public MemoryUsage getTotal() { return total; }
public Map<String, Object> getAdditionalInfo() { return Collections.unmodifiableMap(additionalInfo); }
// Utility methods
public boolean isYoungGC() {
return type == GCEventType.YOUNG_GC || 
gcName.toLowerCase().contains("young") ||
gcName.toLowerCase().contains("minor");
}
public boolean isFullGC() {
return type == GCEventType.FULL_GC || 
gcName.toLowerCase().contains("full") ||
gcName.toLowerCase().contains("major");
}
public long getFreedMemory() {
return before.getUsed() - after.getUsed();
}
public double getThroughput() {
if (total.getSize() == 0) return 0.0;
return (double) getFreedMemory() / total.getSize() * 100.0;
}
public double getCollectionEfficiency() {
if (duration == 0) return 0.0;
return getFreedMemory() / (duration * 1024 * 1024); // MB freed per second
}
@Override
public String toString() {
return String.format("GCEvent[%s, %s, %.3fs, %s]", 
timestamp.format(DateTimeFormatter.ISO_LOCAL_TIME),
type, duration, gcName);
}
}
public class MemoryUsage {
private long used;      // in bytes
private long size;      // in bytes
private long committed; // in bytes
public MemoryUsage() {}
public MemoryUsage(long used, long size, long committed) {
this.used = used;
this.size = size;
this.committed = committed;
}
// Getters and setters
public long getUsed() { return used; }
public void setUsed(long used) { this.used = used; }
public long getSize() { return size; }
public void setSize(long size) { this.size = size; }
public long getCommitted() { return committed; }
public void setCommitted(long committed) { this.committed = committed; }
// Utility methods
public double getUsagePercentage() {
return size > 0 ? (double) used / size * 100.0 : 0.0;
}
public double getCommitPercentage() {
return size > 0 ? (double) committed / size * 100.0 : 0.0;
}
public long getFree() {
return size - used;
}
public double getFreePercentage() {
return size > 0 ? (double) getFree() / size * 100.0 : 0.0;
}
public void copyFrom(MemoryUsage other) {
this.used = other.used;
this.size = other.size;
this.committed = other.committed;
}
@Override
public String toString() {
return String.format("Memory[used=%s, size=%s, committed=%s]", 
formatBytes(used), formatBytes(size), formatBytes(committed));
}
private String formatBytes(long bytes) {
if (bytes < 1024) return bytes + "B";
if (bytes < 1024 * 1024) return String.format("%.1fKB", bytes / 1024.0);
if (bytes < 1024 * 1024 * 1024) return String.format("%.1fMB", bytes / (1024.0 * 1024.0));
return String.format("%.1fGB", bytes / (1024.0 * 1024.0 * 1024.0));
}
}
public enum GCEventType {
YOUNG_GC,
FULL_GC,
CONCURRENT_MARK,
CONCURRENT_SWEEP,
CONCURRENT_RESET,
CONCURRENT_PHASE,
GC_PAUSE,
GC_CYCLE,
UNKNOWN;
public static GCEventType fromString(String type) {
if (type == null) return UNKNOWN;
String lower = type.toLowerCase();
if (lower.contains("young") || lower.contains("minor")) return YOUNG_GC;
if (lower.contains("full") || lower.contains("major")) return FULL_GC;
if (lower.contains("concurrent mark")) return CONCURRENT_MARK;
if (lower.contains("concurrent sweep")) return CONCURRENT_SWEEP;
if (lower.contains("concurrent reset")) return CONCURRENT_RESET;
if (lower.contains("pause")) return GC_PAUSE;
if (lower.contains("cycle")) return GC_CYCLE;
return UNKNOWN;
}
}
public class GCStatistics {
private long totalEvents;
private long youngGCCount;
private long fullGCCount;
private long concurrentEventsCount;
private double totalDuration;
private double youngGCDuration;
private double fullGCDuration;
private double maxGCPause;
private double minGCPause = Double.MAX_VALUE;
private double totalFreedMemory;
private long totalAllocatedMemory;
private final Map<String, Long> gcTypeCounts = new HashMap<>();
private final List<Double> pauseTimes = new ArrayList<>();
private LocalDateTime firstEventTime;
private LocalDateTime lastEventTime;
public void update(GCEvent event) {
totalEvents++;
totalDuration += event.getDuration();
pauseTimes.add(event.getDuration());
// Update min/max pause times
maxGCPause = Math.max(maxGCPause, event.getDuration());
minGCPause = Math.min(minGCPause, event.getDuration());
// Update event type counts
gcTypeCounts.merge(event.getGcName(), 1L, Long::sum);
// Update memory statistics
long freed = event.getFreedMemory();
if (freed > 0) {
totalFreedMemory += freed;
}
// Update timing
if (firstEventTime == null || event.getTimestamp().isBefore(firstEventTime)) {
firstEventTime = event.getTimestamp();
}
if (lastEventTime == null || event.getTimestamp().isAfter(lastEventTime)) {
lastEventTime = event.getTimestamp();
}
// Categorize events
if (event.isYoungGC()) {
youngGCCount++;
youngGCDuration += event.getDuration();
} else if (event.isFullGC()) {
fullGCCount++;
fullGCDuration += event.getDuration();
}
if (event.getType().name().contains("CONCURRENT")) {
concurrentEventsCount++;
}
}
// Getters
public long getTotalEvents() { return totalEvents; }
public long getYoungGCCount() { return youngGCCount; }
public long getFullGCCount() { return fullGCCount; }
public long getConcurrentEventsCount() { return concurrentEventsCount; }
public double getTotalDuration() { return totalDuration; }
public double getYoungGCDuration() { return youngGCDuration; }
public double getFullGCDuration() { return fullGCDuration; }
public double getMaxGCPause() { return maxGCPause == Double.MIN_VALUE ? 0 : maxGCPause; }
public double getMinGCPause() { return minGCPause == Double.MAX_VALUE ? 0 : minGCPause; }
public double getTotalFreedMemory() { return totalFreedMemory; }
public long getTotalAllocatedMemory() { return totalAllocatedMemory; }
public Map<String, Long> getGcTypeCounts() { return Collections.unmodifiableMap(gcTypeCounts); }
public List<Double> getPauseTimes() { return Collections.unmodifiableList(pauseTimes); }
public LocalDateTime getFirstEventTime() { return firstEventTime; }
public LocalDateTime getLastEventTime() { return lastEventTime; }
// Calculated statistics
public double getAveragePauseTime() {
return totalEvents > 0 ? totalDuration / totalEvents : 0.0;
}
public double getThroughput() {
double totalTime = getTotalObservationTime();
return totalTime > 0 ? (1 - (totalDuration / totalTime)) * 100.0 : 0.0;
}
public double getTotalObservationTime() {
if (firstEventTime == null || lastEventTime == null) return 0.0;
return java.time.Duration.between(firstEventTime, lastEventTime).toMillis() / 1000.0;
}
public double getPauseTimePercentile(double percentile) {
if (pauseTimes.isEmpty()) return 0.0;
List<Double> sorted = new ArrayList<>(pauseTimes);
Collections.sort(sorted);
int index = (int) Math.ceil(percentile * sorted.size()) - 1;
index = Math.max(0, Math.min(index, sorted.size() - 1));
return sorted.get(index);
}
public double getYoungGCRate() {
double observationTime = getTotalObservationTime();
return observationTime > 0 ? youngGCCount / observationTime : 0.0;
}
public double getFullGCRate() {
double observationTime = getTotalObservationTime();
return observationTime > 0 ? fullGCCount / observationTime : 0.0;
}
public Map<String, Double> getGCTimeDistribution() {
Map<String, Double> distribution = new HashMap<>();
double total = getTotalDuration();
if (total > 0) {
distribution.put("Young GC", (youngGCDuration / total) * 100);
distribution.put("Full GC", (fullGCDuration / total) * 100);
distribution.put("Concurrent", ((totalDuration - youngGCDuration - fullGCDuration) / total) * 100);
}
return distribution;
}
public String getSummary() {
return String.format(
"GC Statistics: %d events (Young: %d, Full: %d), Throughput: %.2f%%, " +
"Avg Pause: %.3fs, Max Pause: %.3fs",
totalEvents, youngGCCount, fullGCCount, getThroughput(), 
getAveragePauseTime(), getMaxGCPause()
);
}
}

2. GC Log Parser

package com.gcanalyzer.parser;
import com.gcanalyzer.model.*;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class GCLogParser {
// Common GC log patterns for different collectors and formats
private static final Pattern TIMESTAMP_PATTERN = Pattern.compile(
"^(\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3})\\S*"
);
private static final Pattern SIMPLE_GC_PATTERN = Pattern.compile(
"\\[GC.*?(\\d+\\.\\d{3}):.*?(\\d+\\.\\d{3})s\\]"
);
// Unified Logging (Java 9+) patterns
private static final Pattern UNIFIED_GC_PATTERN = Pattern.compile(
"\\[([^]]+)\\]\\s*\\[info\\]\\s*\\[gc.*?\\]\\s*(.*)"
);
// G1GC patterns
private static final Pattern G1GC_PATTERN = Pattern.compile(
"\\[GC pause \\(G1.*?\\) (.*?), (\\d+\\.\\d{3})s\\]"
);
// CMS patterns
private static final Pattern CMS_GC_PATTERN = Pattern.compile(
"\\[GC.*?\\[CMS:.*?\\]"
);
// Parallel GC patterns
private static final Pattern PARALLEL_GC_PATTERN = Pattern.compile(
"\\[GC.*?PSYoungGen.*?\\]"
);
// Memory size patterns (e.g., 1024K->512K(2048K))
private static final Pattern MEMORY_PATTERN = Pattern.compile(
"(\\d+)([KMG]?)[Bb]?->(\\d+)([KMG]?)[Bb]?\\((\\d+)([KMG]?)[Bb]?\\)"
);
// Duration pattern
private static final Pattern DURATION_PATTERN = Pattern.compile(
"(\\d+\\.\\d{3})s"
);
private final Set<String> supportedCollectors = Set.of(
"G1", "CMS", "Parallel", "Serial", "ZGC", "Shenandoah"
);
public GCLog parseFromFile(Path filePath) throws IOException {
String content = Files.readString(filePath);
return parseFromString(content, filePath.toString());
}
public GCLog parseFromString(String content, String source) {
GCLog.Builder logBuilder = new GCLog.Builder().source(source);
String[] lines = content.split("\n");
String detectedCollector = detectCollector(content);
logBuilder.metadata("collector", detectedCollector);
logBuilder.metadata("format", detectFormat(content));
for (String line : lines) {
if (line.trim().isEmpty()) continue;
try {
GCEvent event = parseGCEvent(line, detectedCollector);
if (event != null) {
logBuilder.addEvent(event);
}
} catch (Exception e) {
System.err.println("Failed to parse line: " + line + " - " + e.getMessage());
}
}
return logBuilder.build();
}
private GCEvent parseGCEvent(String line, String collector) {
// Try different parsing strategies based on collector and format
GCEvent event = null;
if (isUnifiedLoggingFormat(line)) {
event = parseUnifiedLoggingEvent(line);
} else if (collector.equals("G1")) {
event = parseG1GCEvent(line);
} else if (collector.equals("CMS")) {
event = parseCMSEvent(line);
} else if (collector.equals("Parallel") || collector.equals("Serial")) {
event = parseParallelEvent(line);
} else {
event = parseGenericEvent(line);
}
return event;
}
private boolean isUnifiedLoggingFormat(String line) {
return line.contains("[gc") && line.contains("] [");
}
private GCEvent parseUnifiedLoggingEvent(String line) {
Matcher matcher = UNIFIED_GC_PATTERN.matcher(line);
if (!matcher.find()) return null;
String timestampStr = matcher.group(1);
String gcDetails = matcher.group(2);
LocalDateTime timestamp = parseTimestamp(timestampStr);
GCEventType type = classifyUnifiedEvent(gcDetails);
String gcName = extractGCName(gcDetails);
double duration = extractDuration(gcDetails);
GCEvent.Builder builder = new GCEvent.Builder()
.timestamp(timestamp)
.type(type)
.gcName(gcName)
.duration(duration);
// Parse memory information
MemoryUsage before = extractMemoryUsage(gcDetails, "before");
MemoryUsage after = extractMemoryUsage(gcDetails, "after");
MemoryUsage total = extractHeapSize(gcDetails);
if (before != null) builder.before(before);
if (after != null) builder.after(after);
if (total != null) builder.total(total);
// Add additional info
builder.additionalInfo("line", line);
builder.additionalInfo("collector", "Unified");
return builder.build();
}
private GCEvent parseG1GCEvent(String line) {
// Parse G1GC specific format
Matcher pauseMatcher = G1GC_PATTERN.matcher(line);
if (!pauseMatcher.find()) return null;
String details = pauseMatcher.group(1);
String durationStr = pauseMatcher.group(2);
LocalDateTime timestamp = extractTimestamp(line);
GCEventType type = classifyG1Event(details);
double duration = Double.parseDouble(durationStr);
GCEvent.Builder builder = new GCEvent.Builder()
.timestamp(timestamp)
.type(type)
.gcName("G1 " + details)
.duration(duration);
// Extract memory information from line
extractG1MemoryInfo(line, builder);
builder.additionalInfo("line", line);
return builder.build();
}
private GCEvent parseCMSEvent(String line) {
// Parse CMS specific format
if (!line.contains("[CMS")) return null;
LocalDateTime timestamp = extractTimestamp(line);
GCEventType type = line.contains("concurrent") ? GCEventType.CONCURRENT_MARK : GCEventType.FULL_GC;
double duration = extractDuration(line);
GCEvent.Builder builder = new GCEvent.Builder()
.timestamp(timestamp)
.type(type)
.gcName("CMS")
.duration(duration);
extractGenericMemoryInfo(line, builder);
builder.additionalInfo("line", line);
return builder.build();
}
private GCEvent parseParallelEvent(String line) {
// Parse Parallel/Serial GC format
if (!line.contains("PSYoungGen") && !line.contains("ParNew") && !line.contains("DefNew")) {
return null;
}
LocalDateTime timestamp = extractTimestamp(line);
GCEventType type = line.contains("Full GC") ? GCEventType.FULL_GC : GCEventType.YOUNG_GC;
double duration = extractDuration(line);
GCEvent.Builder builder = new GCEvent.Builder()
.timestamp(timestamp)
.type(type)
.gcName("Parallel")
.duration(duration);
extractGenericMemoryInfo(line, builder);
builder.additionalInfo("line", line);
return builder.build();
}
private GCEvent parseGenericEvent(String line) {
// Fallback parser for generic GC events
if (!line.contains("GC") && !line.contains("gc")) return null;
LocalDateTime timestamp = extractTimestamp(line);
GCEventType type = classifyGenericEvent(line);
String gcName = "Generic";
double duration = extractDuration(line);
GCEvent.Builder builder = new GCEvent.Builder()
.timestamp(timestamp)
.type(type)
.gcName(gcName)
.duration(duration);
extractGenericMemoryInfo(line, builder);
builder.additionalInfo("line", line);
return builder.build();
}
private LocalDateTime parseTimestamp(String timestampStr) {
try {
// Try ISO format first
return LocalDateTime.parse(timestampStr, DateTimeFormatter.ISO_LOCAL_DATE_TIME);
} catch (Exception e) {
// Try other formats
try {
// Try format without timezone: 2023-10-01T12:00:00.123
if (timestampStr.length() > 23) {
timestampStr = timestampStr.substring(0, 23);
}
return LocalDateTime.parse(timestampStr, DateTimeFormatter.ISO_LOCAL_DATE_TIME);
} catch (Exception e2) {
// Use current time as fallback
return LocalDateTime.now();
}
}
}
private LocalDateTime extractTimestamp(String line) {
Matcher matcher = TIMESTAMP_PATTERN.matcher(line);
if (matcher.find()) {
return parseTimestamp(matcher.group(1));
}
// If no timestamp found, use sequential timing
return LocalDateTime.now();
}
private double extractDuration(String line) {
Matcher matcher = DURATION_PATTERN.matcher(line);
if (matcher.find()) {
return Double.parseDouble(matcher.group(1));
}
return 0.0;
}
private GCEventType classifyUnifiedEvent(String details) {
if (details.contains("Pause Young")) return GCEventType.YOUNG_GC;
if (details.contains("Pause Full")) return GCEventType.FULL_GC;
if (details.contains("Concurrent Mark")) return GCEventType.CONCURRENT_MARK;
if (details.contains("Concurrent Sweep")) return GCEventType.CONCURRENT_SWEEP;
if (details.contains("Concurrent Reset")) return GCEventType.CONCURRENT_RESET;
return GCEventType.UNKNOWN;
}
private GCEventType classifyG1Event(String details) {
if (details.contains("young")) return GCEventType.YOUNG_GC;
if (details.contains("mixed")) return GCEventType.YOUNG_GC; // G1 mixed GC
if (details.contains("full")) return GCEventType.FULL_GC;
return GCEventType.UNKNOWN;
}
private GCEventType classifyGenericEvent(String line) {
if (line.contains("Full GC")) return GCEventType.FULL_GC;
if (line.contains("Young GC")) return GCEventType.YOUNG_GC;
if (line.contains("concurrent")) return GCEventType.CONCURRENT_MARK;
return GCEventType.UNKNOWN;
}
private String extractGCName(String details) {
if (details.contains("G1")) return "G1";
if (details.contains("CMS")) return "CMS";
if (details.contains("Parallel")) return "Parallel";
if (details.contains("ZGC")) return "ZGC";
if (details.contains("Shenandoah")) return "Shenandoah";
return "Unknown";
}
private MemoryUsage extractMemoryUsage(String details, String phase) {
// Look for patterns like "used: 1024K" or "before: 1024K"
Pattern pattern = Pattern.compile(phase + ":?\\s*(\\d+)([KMG]?)B?");
Matcher matcher = pattern.matcher(details);
if (matcher.find()) {
long value = Long.parseLong(matcher.group(1));
String unit = matcher.group(2);
long bytes = convertToBytes(value, unit);
return new MemoryUsage(bytes, 0, 0);
}
return null;
}
private MemoryUsage extractHeapSize(String details) {
// Look for heap size patterns
Pattern pattern = Pattern.compile("heap:\\s*(\\d+)([KMG]?)B?");
Matcher matcher = pattern.matcher(details);
if (matcher.find()) {
long value = Long.parseLong(matcher.group(1));
String unit = matcher.group(2);
long bytes = convertToBytes(value, unit);
return new MemoryUsage(0, bytes, 0);
}
return null;
}
private void extractG1MemoryInfo(String line, GCEvent.Builder builder) {
// Extract memory information from G1GC log line
// Format: 1024K->512K(2048K)
Matcher matcher = MEMORY_PATTERN.matcher(line);
if (matcher.find()) {
long before = convertToBytes(Long.parseLong(matcher.group(1)), matcher.group(2));
long after = convertToBytes(Long.parseLong(matcher.group(3)), matcher.group(4));
long total = convertToBytes(Long.parseLong(matcher.group(5)), matcher.group(6));
builder.before(new MemoryUsage(before, total, total));
builder.after(new MemoryUsage(after, total, total));
builder.total(new MemoryUsage(0, total, total));
}
}
private void extractGenericMemoryInfo(String line, GCEvent.Builder builder) {
// Generic memory info extraction for various formats
Matcher matcher = MEMORY_PATTERN.matcher(line);
if (matcher.find()) {
long before = convertToBytes(Long.parseLong(matcher.group(1)), matcher.group(2));
long after = convertToBytes(Long.parseLong(matcher.group(3)), matcher.group(4));
long total = convertToBytes(Long.parseLong(matcher.group(5)), matcher.group(6));
builder.before(new MemoryUsage(before, total, total));
builder.after(new MemoryUsage(after, total, total));
builder.total(new MemoryUsage(0, total, total));
}
}
private long convertToBytes(long value, String unit) {
if (unit == null || unit.isEmpty()) return value;
switch (unit.toUpperCase()) {
case "K": return value * 1024;
case "M": return value * 1024 * 1024;
case "G": return value * 1024 * 1024 * 1024;
default: return value;
}
}
private String detectCollector(String content) {
if (content.contains("G1")) return "G1";
if (content.contains("CMS")) return "CMS";
if (content.contains("PSYoungGen") || content.contains("ParNew")) return "Parallel";
if (content.contains("DefNew")) return "Serial";
if (content.contains("ZGC")) return "ZGC";
if (content.contains("Shenandoah")) return "Shenandoah";
return "Unknown";
}
private String detectFormat(String content) {
if (content.contains("[gc]") && content.contains("[info]")) return "Unified";
if (content.contains("Java HotSpot")) return "Classic";
return "Generic";
}
// Batch parsing for multiple files
public List<GCLog> parseMultipleFiles(List<Path> filePaths) {
return filePaths.parallelStream()
.map(path -> {
try {
return parseFromFile(path);
} catch (IOException e) {
System.err.println("Failed to parse file: " + path + " - " + e.getMessage());
return null;
}
})
.filter(Objects::nonNull)
.collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
}
}

3. GC Log Analyzer

package com.gcanalyzer.analyzer;
import com.gcanalyzer.model.*;
import java.util.*;
import java.util.stream.Collectors;
public class GCLogAnalyzer {
private final GCLog log;
private final AnalysisResult result;
public GCLogAnalyzer(GCLog log) {
this.log = log;
this.result = new AnalysisResult(log);
}
public AnalysisResult analyze() {
analyzeBasicStatistics();
analyzePauseTimes();
analyzeMemoryUsage();
analyzeGCPatterns();
analyzeThroughput();
detectIssues();
calculatePercentiles();
return result;
}
private void analyzeBasicStatistics() {
GCStatistics stats = log.getStatistics();
result.setBasicStatistics(stats);
// Add derived statistics
result.setYoungGCRate(stats.getYoungGCRate());
result.setFullGCRate(stats.getFullGCRate());
result.setGcTimeDistribution(stats.getGCTimeDistribution());
}
private void analyzePauseTimes() {
List<GCEvent> events = log.getEvents();
// Analyze pause time distribution
Map<String, List<Double>> pauseTimesByType = new HashMap<>();
Map<String, Double> maxPauseByType = new HashMap<>();
Map<String, Double> avgPauseByType = new HashMap<>();
for (GCEvent event : events) {
String type = event.getType().name();
double duration = event.getDuration();
pauseTimesByType.computeIfAbsent(type, k -> new ArrayList<>()).add(duration);
maxPauseByType.merge(type, duration, Math::max);
avgPauseByType.merge(type, duration, Double::sum);
}
// Calculate averages
for (Map.Entry<String, Double> entry : avgPauseByType.entrySet()) {
String type = entry.getKey();
double total = entry.getValue();
long count = pauseTimesByType.get(type).size();
avgPauseByType.put(type, total / count);
}
result.setPauseTimesByType(pauseTimesByType);
result.setMaxPauseByType(maxPauseByType);
result.setAvgPauseByType(avgPauseByType);
// Detect long pauses
detectLongPauses(events);
}
private void detectLongPauses(List<GCEvent> events) {
double threshold = 1.0; // 1 second threshold for long pauses
List<GCEvent> longPauses = events.stream()
.filter(event -> event.getDuration() > threshold)
.collect(Collectors.toList());
result.setLongPauses(longPauses);
if (!longPauses.isEmpty()) {
result.addIssue("LONG_PAUSES", 
String.format("Found %d GC pauses longer than %.1f seconds", 
longPauses.size(), threshold));
}
}
private void analyzeMemoryUsage() {
List<GCEvent> events = log.getEvents();
// Analyze memory usage patterns
List<Double> heapUsagePercentages = new ArrayList<>();
List<Double> youngGenUsage = new ArrayList<>();
List<Double> oldGenUsage = new ArrayList<>();
for (GCEvent event : events) {
MemoryUsage before = event.getBefore();
MemoryUsage total = event.getTotal();
if (before.getSize() > 0) {
double usage = before.getUsagePercentage();
heapUsagePercentages.add(usage);
// Categorize by generation (simplified)
if (event.isYoungGC()) {
youngGenUsage.add(usage);
} else if (event.isFullGC()) {
oldGenUsage.add(usage);
}
}
}
result.setHeapUsagePercentages(heapUsagePercentages);
result.setYoungGenUsage(youngGenUsage);
result.setOldGenUsage(oldGenUsage);
// Analyze memory efficiency
analyzeMemoryEfficiency(events);
}
private void analyzeMemoryEfficiency(List<GCEvent> events) {
double totalFreed = 0;
double totalPauseTime = 0;
for (GCEvent event : events) {
if (event.getDuration() > 0) {
totalFreed += event.getFreedMemory();
totalPauseTime += event.getDuration();
}
}
double efficiency = totalPauseTime > 0 ? totalFreed / (totalPauseTime * 1024 * 1024) : 0;
result.setMemoryEfficiency(efficiency);
if (efficiency < 100) { // Less than 100 MB freed per second of pause
result.addIssue("LOW_MEMORY_EFFICIENCY", 
String.format("Low memory cleanup efficiency: %.1f MB/s", efficiency));
}
}
private void analyzeGCPatterns() {
List<GCEvent> events = log.getEvents();
// Analyze GC frequency patterns
analyzeGCFrequency(events);
// Analyze Full GC patterns
analyzeFullGCPatterns(events);
// Analyze concurrent phase patterns
analyzeConcurrentPatterns(events);
}
private void analyzeGCFrequency(List<GCEvent> events) {
if (events.size() < 2) return;
List<Double> intervals = new ArrayList<>();
GCEvent previous = events.get(0);
for (int i = 1; i < events.size(); i++) {
GCEvent current = events.get(i);
double interval = java.time.Duration.between(
previous.getTimestamp(), current.getTimestamp()
).toMillis() / 1000.0;
intervals.add(interval);
previous = current;
}
// Calculate statistics
double avgInterval = intervals.stream().mapToDouble(D -> D).average().orElse(0);
double maxInterval = intervals.stream().mapToDouble(D -> D).max().orElse(0);
double minInterval = intervals.stream().mapToDouble(D -> D).min().orElse(0);
result.setGcIntervals(intervals);
result.setAvgGcInterval(avgInterval);
result.setMaxGcInterval(maxInterval);
result.setMinGcInterval(minInterval);
// Detect frequent GC
if (avgInterval < 1.0) { // Less than 1 second between GCs
result.addIssue("FREQUENT_GC", 
String.format("Frequent GC: average interval %.2f seconds", avgInterval));
}
}
private void analyzeFullGCPatterns(List<GCEvent> events) {
List<GCEvent> fullGCs = events.stream()
.filter(GCEvent::isFullGC)
.collect(Collectors.toList());
result.setFullGCEvents(fullGCs);
if (!fullGCs.isEmpty()) {
result.addIssue("FULL_GC_DETECTED", 
String.format("Found %d Full GC events", fullGCs.size()));
// Check if Full GCs are too frequent
if (fullGCs.size() > log.getStatistics().getTotalEvents() * 0.1) {
result.addIssue("FREQUENT_FULL_GC", 
"More than 10% of GC events are Full GCs");
}
}
}
private void analyzeConcurrentPatterns(List<GCEvent> events) {
List<GCEvent> concurrentEvents = events.stream()
.filter(event -> event.getType().name().contains("CONCURRENT"))
.collect(Collectors.toList());
result.setConcurrentEvents(concurrentEvents);
// Analyze concurrent phase durations
Map<String, List<Double>> concurrentDurations = new HashMap<>();
for (GCEvent event : concurrentEvents) {
String phase = event.getType().name();
concurrentDurations.computeIfAbsent(phase, k -> new ArrayList<>())
.add(event.getDuration());
}
result.setConcurrentDurations(concurrentDurations);
}
private void analyzeThroughput() {
GCStatistics stats = log.getStatistics();
double throughput = stats.getThroughput();
result.setThroughput(throughput);
if (throughput < 95.0) {
result.addIssue("LOW_THROUGHPUT", 
String.format("Low application throughput: %.1f%%", throughput));
}
if (throughput < 90.0) {
result.addIssue("CRITICAL_THROUGHPUT", 
String.format("Critical throughput issue: %.1f%%", throughput));
}
}
private void detectIssues() {
GCStatistics stats = log.getStatistics();
// Memory issues
if (stats.getFullGCCount() > 0) {
result.addIssue("MEMORY_PRESSURE", "Memory pressure detected (Full GC occurred)");
}
// Pause time issues
if (stats.getMaxGCPause() > 5.0) {
result.addIssue("VERY_LONG_PAUSE", 
String.format("Very long GC pause: %.2f seconds", stats.getMaxGCPause()));
}
// Allocation rate issues
analyzeAllocationRate();
// Heap size issues
analyzeHeapSize();
}
private void analyzeAllocationRate() {
// Simplified allocation rate analysis
List<GCEvent> events = log.getEvents();
if (events.size() < 10) return;
double totalAllocated = 0;
double totalTime = log.getStatistics().getTotalObservationTime();
for (GCEvent event : events) {
totalAllocated += event.getBefore().getUsed();
}
double avgAllocationRate = totalTime > 0 ? totalAllocated / totalTime / (1024 * 1024) : 0;
result.setAllocationRate(avgAllocationRate);
if (avgAllocationRate > 500) { // More than 500 MB/s
result.addIssue("HIGH_ALLOCATION_RATE", 
String.format("High allocation rate: %.1f MB/s", avgAllocationRate));
}
}
private void analyzeHeapSize() {
// Analyze if heap size might be inappropriate
List<GCEvent> events = log.getEvents();
if (events.isEmpty()) return;
double avgHeapUsage = events.stream()
.mapToDouble(event -> event.getBefore().getUsagePercentage())
.average()
.orElse(0);
result.setAvgHeapUsage(avgHeapUsage);
if (avgHeapUsage > 80.0) {
result.addIssue("HIGH_HEAP_USAGE", 
String.format("High average heap usage: %.1f%%", avgHeapUsage));
}
if (avgHeapUsage < 30.0) {
result.addIssue("LOW_HEAP_USAGE", 
String.format("Potentially oversized heap: %.1f%% average usage", avgHeapUsage));
}
}
private void calculatePercentiles() {
GCStatistics stats = log.getStatistics();
Map<String, Double> pausePercentiles = new HashMap<>();
pausePercentiles.put("50th", stats.getPauseTimePercentile(0.50));
pausePercentiles.put("75th", stats.getPauseTimePercentile(0.75));
pausePercentiles.put("90th", stats.getPauseTimePercentile(0.90));
pausePercentiles.put("95th", stats.getPauseTimePercentile(0.95));
pausePercentiles.put("99th", stats.getPauseTimePercentile(0.99));
result.setPauseTimePercentiles(pausePercentiles);
}
}
public class AnalysisResult {
private final GCLog log;
private GCStatistics basicStatistics;
private double throughput;
private double youngGCRate;
private double fullGCRate;
private Map<String, Double> gcTimeDistribution;
private Map<String, List<Double>> pauseTimesByType;
private Map<String, Double> maxPauseByType;
private Map<String, Double> avgPauseByType;
private List<GCEvent> longPauses;
private List<Double> heapUsagePercentages;
private List<Double> youngGenUsage;
private List<Double> oldGenUsage;
private double memoryEfficiency;
private List<Double> gcIntervals;
private double avgGcInterval;
private double maxGcInterval;
private double minGcInterval;
private List<GCEvent> fullGCEvents;
private List<GCEvent> concurrentEvents;
private Map<String, List<Double>> concurrentDurations;
private double allocationRate;
private double avgHeapUsage;
private Map<String, Double> pauseTimePercentiles;
private final List<String> issues = new ArrayList<>();
public AnalysisResult(GCLog log) {
this.log = log;
}
// Getters and setters
public GCLog getLog() { return log; }
public GCStatistics getBasicStatistics() { return basicStatistics; }
public void setBasicStatistics(GCStatistics basicStatistics) { this.basicStatistics = basicStatistics; }
public double getThroughput() { return throughput; }
public void setThroughput(double throughput) { this.throughput = throughput; }
public double getYoungGCRate() { return youngGCRate; }
public void setYoungGCRate(double youngGCRate) { this.youngGCRate = youngGCRate; }
public double getFullGCRate() { return fullGCRate; }
public void setFullGCRate(double fullGCRate) { this.fullGCRate = fullGCRate; }
public Map<String, Double> getGcTimeDistribution() { return gcTimeDistribution; }
public void setGcTimeDistribution(Map<String, Double> gcTimeDistribution) { this.gcTimeDistribution = gcTimeDistribution; }
public Map<String, List<Double>> getPauseTimesByType() { return pauseTimesByType; }
public void setPauseTimesByType(Map<String, List<Double>> pauseTimesByType) { this.pauseTimesByType = pauseTimesByType; }
public Map<String, Double> getMaxPauseByType() { return maxPauseByType; }
public void setMaxPauseByType(Map<String, Double> maxPauseByType) { this.maxPauseByType = maxPauseByType; }
public Map<String, Double> getAvgPauseByType() { return avgPauseByType; }
public void setAvgPauseByType(Map<String, Double> avgPauseByType) { this.avgPauseByType = avgPauseByType; }
public List<GCEvent> getLongPauses() { return longPauses; }
public void setLongPauses(List<GCEvent> longPauses) { this.longPauses = longPauses; }
public List<Double> getHeapUsagePercentages() { return heapUsagePercentages; }
public void setHeapUsagePercentages(List<Double> heapUsagePercentages) { this.heapUsagePercentages = heapUsagePercentages; }
public List<Double> getYoungGenUsage() { return youngGenUsage; }
public void setYoungGenUsage(List<Double> youngGenUsage) { this.youngGenUsage = youngGenUsage; }
public List<Double> getOldGenUsage() { return oldGenUsage; }
public void setOldGenUsage(List<Double> oldGenUsage) { this.oldGenUsage = oldGenUsage; }
public double getMemoryEfficiency() { return memoryEfficiency; }
public void setMemoryEfficiency(double memoryEfficiency) { this.memoryEfficiency = memoryEfficiency; }
public List<Double> getGcIntervals() { return gcIntervals; }
public void setGcIntervals(List<Double> gcIntervals) { this.gcIntervals = gcIntervals; }
public double getAvgGcInterval() { return avgGcInterval; }
public void setAvgGcInterval(double avgGcInterval) { this.avgGcInterval = avgGcInterval; }
public double getMaxGcInterval() { return maxGcInterval; }
public void setMaxGcInterval(double maxGcInterval) { this.maxGcInterval = maxGcInterval; }
public double getMinGcInterval() { return minGcInterval; }
public void setMinGcInterval(double minGcInterval) { this.minGcInterval = minGcInterval; }
public List<GCEvent> getFullGCEvents() { return fullGCEvents; }
public void setFullGCEvents(List<GCEvent> fullGCEvents) { this.fullGCEvents = fullGCEvents; }
public List<GCEvent> getConcurrentEvents() { return concurrentEvents; }
public void setConcurrentEvents(List<GCEvent> concurrentEvents) { this.concurrentEvents = concurrentEvents; }
public Map<String, List<Double>> getConcurrentDurations() { return concurrentDurations; }
public void setConcurrentDurations(Map<String, List<Double>> concurrentDurations) { this.concurrentDurations = concurrentDurations; }
public double getAllocationRate() { return allocationRate; }
public void setAllocationRate(double allocationRate) { this.allocationRate = allocationRate; }
public double getAvgHeapUsage() { return avgHeapUsage; }
public void setAvgHeapUsage(double avgHeapUsage) { this.avgHeapUsage = avgHeapUsage; }
public Map<String, Double> getPauseTimePercentiles() { return pauseTimePercentiles; }
public void setPauseTimePercentiles(Map<String, Double> pauseTimePercentiles) { this.pauseTimePercentiles = pauseTimePercentiles; }
public List<String> getIssues() { return Collections.unmodifiableList(issues); }
public void addIssue(String type, String description) { issues.add(type + ": " + description); }
public boolean hasIssues() { return !issues.isEmpty(); }
public int getIssueCount() { return issues.size(); }
public List<String> getIssuesBySeverity() {
return issues.stream()
.sorted(this::compareIssueSeverity)
.collect(Collectors.toList());
}
private int compareIssueSeverity(String a, String b) {
int severityA = getSeverity(a);
int severityB = getSeverity(b);
return Integer.compare(severityB, severityA); // Descending
}
private int getSeverity(String issue) {
if (issue.contains("CRITICAL") || issue.contains("VERY_LONG")) return 3;
if (issue.contains("FULL_GC") || issue.contains("HIGH_")) return 2;
return 1;
}
public String getSummary() {
return String.format(
"Analysis Result: %d events, %.1f%% throughput, %d issues found",
basicStatistics.getTotalEvents(), throughput, issues.size()
);
}
}

4. HTML Report Generator

package com.gcanalyzer.reporter;
import com.gcanalyzer.model.*;
import com.gcanalyzer.analyzer.AnalysisResult;
import java.io.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;
public class HTMLReportGenerator {
public void generateReport(AnalysisResult result, Path outputDir) throws IOException {
String htmlContent = generateHTMLContent(result);
Path outputFile = outputDir.resolve("gc-analysis-report.html");
Files.writeString(outputFile, htmlContent);
System.out.println("HTML report generated: " + outputFile.toAbsolutePath());
}
private String generateHTMLContent(AnalysisResult result) {
StringBuilder html = new StringBuilder();
html.append("""
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>GC Log Analysis Report</title>
<style>
body { font-family: Arial, sans-serif; margin: 20px; background-color: #f5f5f5; }
.container { max-width: 1400px; margin: 0 auto; background: white; padding: 20px; border-radius: 8px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
.header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 30px; border-radius: 8px; margin-bottom: 20px; }
.section { margin-bottom: 30px; padding: 20px; border: 1px solid #e0e0e0; border-radius: 8px; background: #fafafa; }
.section-title { color: #2c3e50; border-bottom: 3px solid #3498db; padding-bottom: 10px; margin-top: 0; font-size: 1.4em; }
.issue { padding: 12px; margin: 8px 0; border-radius: 6px; font-weight: 500; }
.issue-critical { background: #ffebee; border-left: 5px solid #f44336; color: #c62828; }
.issue-warning { background: #fff3e0; border-left: 5px solid #ff9800; color: #ef6c00; }
.issue-info { background: #e8f5e8; border-left: 5px solid #4caf50; color: #2e7d32; }
.stat-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); gap: 20px; margin: 20px 0; }
.stat-card { background: white; padding: 20px; border-radius: 8px; text-align: center; box-shadow: 0 2px 5px rgba(0,0,0,0.1); border-left: 4px solid #3498db; }
.stat-value { font-size: 28px; font-weight: bold; color: #2c3e50; margin: 10px 0; }
.stat-label { color: #7f8c8d; font-size: 14px; text-transform: uppercase; letter-spacing: 1px; }
.chart-container { height: 400px; margin: 25px 0; background: white; padding: 15px; border-radius: 8px; box-shadow: 0 2px 5px rgba(0,0,0,0.1); }
table { width: 100%; border-collapse: collapse; margin-top: 15px; background: white; border-radius: 8px; overflow: hidden; box-shadow: 0 2px 5px rgba(0,0,0,0.1); }
th, td { padding: 15px; text-align: left; border-bottom: 1px solid #e0e0e0; }
th { background-color: #34495e; color: white; font-weight: 600; }
tr:hover { background-color: #f5f5f5; }
.badge { display: inline-block; padding: 5px 12px; border-radius: 15px; font-size: 12px; font-weight: bold; margin: 2px; }
.badge-success { background: #d4edda; color: #155724; }
.badge-warning { background: #fff3cd; color: #856404; }
.badge-danger { background: #f8d7da; color: #721c24; }
.badge-info { background: #d1ecf1; color: #0c5460; }
.progress-bar { background: #ecf0f1; border-radius: 10px; overflow: hidden; height: 20px; margin: 10px 0; }
.progress-fill { height: 100%; background: linear-gradient(90deg, #2ecc71, #3498db); transition: width 0.3s ease; }
.summary-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 20px; }
@media (max-width: 768px) {
.summary-grid { grid-template-columns: 1fr; }
.stat-grid { grid-template-columns: 1fr 1fr; }
}
</style>
<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
<script src="https://cdn.jsdelivr.net/npm/[email protected]/min/moment.min.js"></script>
</head>
<body>
<div class="container">
""");
// Header
html.append("""
<div class="header">
<h1 style="margin: 0; font-size: 2.2em;">🚀 GC Log Analysis Report</h1>
<p style="margin: 10px 0 0 0; font-size: 1.1em; opacity: 0.9;">
Generated on: """ + java.time.LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")) + """ | 
Source: """ + escapeHtml(result.getLog().getSource()) + """
</p>
</div>
""");
// Executive Summary
html.append(generateExecutiveSummary(result));
// Key Metrics
html.append(generateKeyMetrics(result));
// Issues
html.append(generateIssuesSection(result));
// GC Statistics
html.append(generateGCStatistics(result));
// Pause Time Analysis
html.append(generatePauseTimeAnalysis(result));
// Memory Analysis
html.append(generateMemoryAnalysis(result));
// Throughput Analysis
html.append(generateThroughputAnalysis(result));
// Recommendations
html.append(generateRecommendations(result));
html.append("""
</div>
<script>
""");
// JavaScript for charts
html.append(generateChartsJavaScript(result));
html.append("""
</script>
</body>
</html>
""");
return html.toString();
}
private String generateExecutiveSummary(AnalysisResult result) {
StringBuilder html = new StringBuilder();
GCStatistics stats = result.getBasicStatistics();
html.append("""
<div class="section">
<h2 class="section-title">📊 Executive Summary</h2>
<div class="summary-grid">
<div>
<h3 style="color: #2c3e50; margin-top: 0;">Performance Overview</h3>
<div class="stat-grid">
""");
// Key metrics
html.append(createStatCard("Total GC Events", String.valueOf(stats.getTotalEvents()), "#3498db"));
html.append(createStatCard("Throughput", String.format("%.1f%%", result.getThroughput()), 
result.getThroughput() > 95 ? "#2ecc71" : "#e74c3c"));
html.append(createStatCard("Avg Pause Time", String.format("%.3fs", stats.getAveragePauseTime()), 
stats.getAveragePauseTime() < 0.1 ? "#2ecc71" : "#e74c3c"));
html.append(createStatCard("Max Pause Time", String.format("%.3fs", stats.getMaxGCPause()), 
stats.getMaxGCPause() < 1.0 ? "#2ecc71" : "#e74c3c"));
html.append("""
</div>
</div>
<div>
<h3 style="color: #2c3e50; margin-top: 0;">GC Distribution</h3>
""");
// GC type distribution
html.append("""
<div style="background: white; padding: 15px; border-radius: 8px; box-shadow: 0 2px 5px rgba(0,0,0,0.1);">
<div class="chart-container">
<canvas id="gcDistributionChart"></canvas>
</div>
</div>
""");
html.append("""
</div>
</div>
</div>
""");
return html.toString();
}
private String generateKeyMetrics(AnalysisResult result) {
GCStatistics stats = result.getBasicStatistics();
StringBuilder html = new StringBuilder();
html.append("""
<div class="section">
<h2 class="section-title">📈 Key Metrics</h2>
<div class="stat-grid">
""");
html.append(createStatCard("Young GC Count", String.valueOf(stats.getYoungGCCount()), "#3498db"));
html.append(createStatCard("Full GC Count", String.valueOf(stats.getFullGCCount()), 
stats.getFullGCCount() == 0 ? "#2ecc71" : "#e74c3c"));
html.append(createStatCard("Young GC Rate", String.format("%.2f/s", result.getYoungGCRate()), 
result.getYoungGCRate() < 1.0 ? "#2ecc71" : "#e74c3c"));
html.append(createStatCard("Total GC Time", String.format("%.1fs", stats.getTotalDuration()), "#3498db"));
html.append(createStatCard("Observation Time", String.format("%.1fs", stats.getTotalObservationTime()), "#3498db"));
html.append(createStatCard("Allocation Rate", String.format("%.1f MB/s", result.getAllocationRate()), 
result.getAllocationRate() < 200 ? "#2ecc71" : "#e74c3c"));
html.append("""
</div>
</div>
""");
return html.toString();
}
private String generateIssuesSection(AnalysisResult result) {
if (!result.hasIssues()) {
return """
<div class="section">
<h2 class="section-title">✅ No Issues Detected</h2>
<div style="text-align: center; padding: 40px; color: #27ae60;">
<h3 style="margin: 0;">Great! No significant GC issues detected.</h3>
<p>The GC configuration appears to be well-tuned for the current workload.</p>
</div>
</div>
""";
}
StringBuilder html = new StringBuilder();
html.append("""
<div class="section">
<h2 class="section-title">⚠️ Detected Issues</h2>
<p><strong>Found """ + result.getIssueCount() + """ issues that may require attention:</strong></p>
""");
for (String issue : result.getIssuesBySeverity()) {
String issueClass = getIssueClass(issue);
html.append("""
<div class="issue """ + issueClass + """">
""" + escapeHtml(issue) + """
</div>
""");
}
html.append("</div>");
return html.toString();
}
private String generateGCStatistics(AnalysisResult result) {
GCStatistics stats = result.getBasicStatistics();
StringBuilder html = new StringBuilder();
html.append("""
<div class="section">
<h2 class="section-title">🔍 Detailed GC Statistics</h2>
<div class="chart-container">
<canvas id="pauseTimeChart"></canvas>
</div>
<table>
<thead>
<tr>
<th>Metric</th>
<th>Value</th>
<th>Status</th>
</tr>
</thead>
<tbody>
""");
// Add statistics rows
addTableRow(html, "Total GC Events", String.valueOf(stats.getTotalEvents()), "info");
addTableRow(html, "Young GC Events", String.valueOf(stats.getYoungGCCount()), "info");
addTableRow(html, "Full GC Events", String.valueOf(stats.getFullGCCount()), 
stats.getFullGCCount() == 0 ? "success" : "danger");
addTableRow(html, "Total GC Time", String.format("%.3f seconds", stats.getTotalDuration()), "info");
addTableRow(html, "Average Pause", String.format("%.3f seconds", stats.getAveragePauseTime()), 
stats.getAveragePauseTime() < 0.1 ? "success" : "warning");
addTableRow(html, "Maximum Pause", String.format("%.3f seconds", stats.getMaxGCPause()), 
stats.getMaxGCPause() < 1.0 ? "success" : "danger");
addTableRow(html, "Throughput", String.format("%.1f%%", result.getThroughput()), 
result.getThroughput() > 95 ? "success" : "warning");
// Percentiles
if (result.getPauseTimePercentiles() != null) {
for (Map.Entry<String, Double> entry : result.getPauseTimePercentiles().entrySet()) {
addTableRow(html, entry.getKey() + " Percentile", 
String.format("%.3f seconds", entry.getValue()), "info");
}
}
html.append("""
</tbody>
</table>
</div>
""");
return html.toString();
}
private String generatePauseTimeAnalysis(AnalysisResult result) {
StringBuilder html = new StringBuilder();
html.append("""
<div class="section">
<h2 class="section-title">⏱️ Pause Time Analysis</h2>
<div class="chart-container">
<canvas id="pauseDistributionChart"></canvas>
</div>
""");
if (result.getLongPauses() != null && !result.getLongPauses().isEmpty()) {
html.append("""
<h3>Long Pauses (> 1.0s)</h3>
<table>
<thead>
<tr>
<th>Timestamp</th>
<th>GC Type</th>
<th>Duration</th>
<th>Freed Memory</th>
</tr>
</thead>
<tbody>
""");
for (GCEvent pause : result.getLongPauses()) {
html.append(String.format("""
<tr>
<td>%s</td>
<td>%s</td>
<td>%.3fs</td>
<td>%s</td>
</tr>
""", 
pause.getTimestamp().format(DateTimeFormatter.ISO_LOCAL_TIME),
pause.getGcName(),
pause.getDuration(),
formatBytes(pause.getFreedMemory())
));
}
html.append("""
</tbody>
</table>
""");
}
html.append("</div>");
return html.toString();
}
private String generateMemoryAnalysis(AnalysisResult result) {
StringBuilder html = new StringBuilder();
html.append("""
<div class="section">
<h2 class="section-title">💾 Memory Analysis</h2>
<div class="chart-container">
<canvas id="memoryUsageChart"></canvas>
</div>
<div class="stat-grid">
""");
html.append(createStatCard("Avg Heap Usage", String.format("%.1f%%", result.getAvgHeapUsage()), 
result.getAvgHeapUsage() < 70 ? "#2ecc71" : "#e74c3c"));
html.append(createStatCard("Memory Efficiency", String.format("%.1f MB/s", result.getMemoryEfficiency()), 
result.getMemoryEfficiency() > 100 ? "#2ecc71" : "#e74c3c"));
html.append(createStatCard("Total Freed", formatBytes((long) result.getBasicStatistics().getTotalFreedMemory()), "#3498db"));
html.append("""
</div>
</div>
""");
return html.toString();
}
private String generateThroughputAnalysis(AnalysisResult result) {
StringBuilder html = new StringBuilder();
html.append("""
<div class="section">
<h2 class="section-title">⚡ Throughput Analysis</h2>
<div style="text-align: center; margin: 20px 0;">
<div style="display: inline-block; width: 200px; height: 200px;">
<canvas id="throughputGauge"></canvas>
</div>
</div>
<div class="progress-bar">
<div class="progress-fill" style="width: """ + Math.min(100, result.getThroughput()) + """%;"></div>
</div>
<div style="text-align: center; color: #7f8c8d; font-size: 14px;">
Application Throughput: """ + String.format("%.1f%%", result.getThroughput()) + """
</div>
</div>
""");
return html.toString();
}
private String generateRecommendations(AnalysisResult result) {
List<String> recommendations = new ArrayList<>();
GCStatistics stats = result.getBasicStatistics();
// Generate recommendations based on analysis
if (result.getThroughput() < 95) {
recommendations.add("Consider tuning GC parameters to improve throughput");
}
if (stats.getFullGCCount() > 0) {
recommendations.add("Investigate memory leaks or increase heap size to avoid Full GC");
}
if (stats.getMaxGCPause() > 1.0) {
recommendations.add("Long GC pauses detected. Consider using low-pause collectors like G1 or ZGC");
}
if (result.getAvgHeapUsage() > 80) {
recommendations.add("High heap usage. Consider increasing heap size or optimizing memory usage");
}
if (result.getAvgHeapUsage() < 30) {
recommendations.add("Low heap usage. Consider reducing heap size to improve memory locality");
}
if (result.getAllocationRate() > 500) {
recommendations.add("High allocation rate. Consider optimizing object creation patterns");
}
if (recommendations.isEmpty()) {
recommendations.add("Current GC configuration appears optimal for the observed workload");
}
StringBuilder html = new StringBuilder();
html.append("""
<div class="section">
<h2 class="section-title">💡 Recommendations</h2>
<ul style="line-height: 1.6;">
""");
for (String recommendation : recommendations) {
html.append("<li>").append(escapeHtml(recommendation)).append("</li>");
}
html.append("""
</ul>
</div>
""");
return html.toString();
}
// Helper methods
private String createStatCard(String label, String value, String color) {
return String.format("""
<div class="stat-card" style="border-left-color: %s;">
<div class="stat-label">%s</div>
<div class="stat-value">%s</div>
</div>
""", color, label, value);
}
private void addTableRow(StringBuilder html, String metric, String value, String badgeType) {
html.append(String.format("""
<tr>
<td><strong>%s</strong></td>
<td>%s</td>
<td><span class="badge badge-%s">%s</span></td>
</tr>
""", metric, value, badgeType, badgeType.toUpperCase()));
}
private String getIssueClass(String issue) {
if (issue.contains("CRITICAL") || issue.contains("VERY_LONG")) return "issue-critical";
if (issue.contains("FULL_GC") || issue.contains("HIGH_")) return "issue-warning";
return "issue-info";
}
private String formatBytes(long bytes) {
if (bytes < 1024) return bytes + "B";
if (bytes < 1024 * 1024) return String.format("%.1fKB", bytes / 1024.0);
if (bytes < 1024 * 1024 * 1024) return String.format("%.1fMB", bytes / (1024.0 * 1024.0));
return String.format("%.1fGB", bytes / (1024.0 * 1024.0 * 1024.0));
}
private String escapeHtml(String text) {
if (text == null) return "";
return text.replace("&", "&amp;")
.replace("<", "&lt;")
.replace(">", "&gt;")
.replace("\"", "&quot;")
.replace("'", "&#39;");
}
private String generateChartsJavaScript(AnalysisResult result) {
StringBuilder js = new StringBuilder();
GCStatistics stats = result.getBasicStatistics();
// GC Distribution Chart
js.append("""
var gcDistributionCtx = document.getElementById('gcDistributionChart').getContext('2d');
var gcDistributionChart = new Chart(gcDistributionCtx, {
type: 'doughnut',
data: {
labels: ['Young GC', 'Full GC', 'Concurrent'],
datasets: [{
data: [""" + stats.getYoungGCCount() + ", " + stats.getFullGCCount() + ", " + stats.getConcurrentEventsCount() + """],
backgroundColor: ['#3498db', '#e74c3c', '#2ecc71'],
borderWidth: 2,
borderColor: '#fff'
}]
},
options: {
responsive: true,
maintainAspectRatio: false,
plugins: {
legend: { position: 'bottom' },
title: { display: true, text: 'GC Event Distribution' }
}
}
});
""");
// Pause Time Chart
js.append("""
var pauseTimeCtx = document.getElementById('pauseTimeChart').getContext('2d');
var pauseTimeChart = new Chart(pauseTimeCtx, {
type: 'line',
data: {
labels: """ + generateTimeLabels(stats) + """,
datasets: [{
label: 'GC Pause Times',
data: """ + generatePauseTimeData(stats) + """,
borderColor: '#e74c3c',
backgroundColor: 'rgba(231, 76, 60, 0.1)',
tension: 0.4,
fill: true
}]
},
options: {
responsive: true,
maintainAspectRatio: false,
plugins: {
title: { display: true, text: 'GC Pause Time Trend' }
},
scales: {
y: {
beginAtZero: true,
title: { display: true, text: 'Pause Time (seconds)' }
}
}
}
});
""");
return js.toString();
}
private String generateTimeLabels(GCStatistics stats) {
// Generate time-based labels for charts
List<String> labels = new ArrayList<>();
if (stats.getPauseTimes().size() > 50) {
// Sample for large datasets
for (int i = 0; i < 50; i++) {
int index = i * stats.getPauseTimes().size() / 50;
labels.add(String.valueOf(index));
}
} else {
for (int i = 0; i < stats.getPauseTimes().size(); i++) {
labels.add(String.valueOf(i));
}
}
return "[" + labels.stream().map(l -> "'" + l + "'").collect(Collectors.joining(", ")) + "]";
}
private String generatePauseTimeData(GCStatistics stats) {
List<String> data = new ArrayList<>();
if (stats.getPauseTimes().size() > 50) {
// Sample for large datasets
for (int i = 0; i < 50; i++) {
int index = i * stats.getPauseTimes().size() / 50;
data.add(String.valueOf(stats.getPauseTimes().get(index)));
}
} else {
for (Double pause : stats.getPauseTimes()) {
data.add(String.valueOf(pause));
}
}
return "[" + String.join(", ", data) + "]";
}
}

5. CLI Interface

package com.gcanalyzer.cli;
import com.gcanalyzer.analyzer.AnalysisResult;
import com.gcanalyzer.analyzer.GCLogAnalyzer;
import com.gcanalyzer.model.GCLog;
import com.gcanalyzer.parser.GCLogParser;
import com.gcanalyzer.reporter.HTMLReportGenerator;
import picocli.CommandLine;
import picocli.CommandLine.Command;
import picocli.CommandLine.Option;
import picocli.CommandLine.Parameters;
import java.io.File;
import java.nio.file.Path;
import java.util.List;
import java.util.concurrent.Callable;
@Command(name = "gcanalyzer", 
mixinStandardHelpOptions = true,
version = "GC Log Analyzer 1.0",
description = "Analyzes Java GC logs and generates comprehensive reports")
public class CLIRunner implements Callable<Integer> {
@Parameters(index = "0", description = "GC log file or directory")
private File input;
@Option(names = {"-o", "--output"}, 
description = "Output directory for reports (default: ./gc-reports)")
private File outputDir = new File("./gc-reports");
@Option(names = {"--format"}, 
description = "Output format: ${COMPLETION-CANDIDATES} (default: HTML)")
private OutputFormat format = OutputFormat.HTML;
@Option(names = {"--detector"}, 
description = "GC detector type: ${COMPLETION-CANDIDATES} (default: AUTO)")
private DetectorType detector = DetectorType.AUTO;
@Option(names = {"--verbose"}, 
description = "Enable verbose output")
private boolean verbose = false;
private final GCLogParser parser = new GCLogParser();
public enum OutputFormat {
HTML, TEXT, JSON
}
public enum DetectorType {
AUTO, G1, CMS, PARALLEL, SERIAL, ZGC, SHENANDOAH
}
@Override
public Integer call() throws Exception {
if (!input.exists()) {
System.err.println("Error: Input file/directory does not exist: " + input.getAbsolutePath());
return 1;
}
if (!outputDir.exists()) {
outputDir.mkdirs();
}
try {
List<GCLog> logs = loadGCLogs();
if (logs.isEmpty()) {
System.err.println("Error: No valid GC logs found in: " + input.getAbsolutePath());
return 1;
}
System.out.println("📁 Loaded " + logs.size() + " GC log file(s)");
for (GCLog log : logs) {
System.out.println("\n🔍 Analyzing: " + log.getSource());
analyzeLog(log);
}
System.out.println("\n✅ Analysis completed. Reports saved to: " + outputDir.getAbsolutePath());
return 0;
} catch (Exception e) {
System.err.println("❌ Error during analysis: " + e.getMessage());
if (verbose) {
e.printStackTrace();
}
return 1;
}
}
private List<GCLog> loadGCLogs() throws Exception {
if (input.isFile()) {
GCLog log = parser.parseFromFile(input.toPath());
return List.of(log);
} else if (input.isDirectory()) {
// Load all GC log files from directory
File[] files = input.listFiles((dir, name) -> 
name.toLowerCase().endsWith(".log") ||
name.toLowerCase().contains("gc") ||
name.toLowerCase().endsWith(".txt") ||
name.toLowerCase().endsWith(".gclog"));
if (files == null || files.length == 0) {
return List.of();
}
return parser.parseMultipleFiles(
List.of(files).stream()
.map(File::toPath)
.collect(java.util.stream.Collectors.toList())
);
}
return List.of();
}
private void analyzeLog(GCLog log) throws Exception {
// Perform analysis
GCLogAnalyzer analyzer = new GCLogAnalyzer(log);
AnalysisResult result = analyzer.analyze();
// Generate report based on format
switch (format) {
case HTML:
generateHTMLReport(log, result);
break;
case TEXT:
generateTextReport(log, result);
break;
case JSON:
generateJSONReport(log, result);
break;
}
// Print summary to console
printConsoleSummary(result);
}
private void generateHTMLReport(GCLog log, AnalysisResult result) throws Exception {
HTMLReportGenerator reporter = new HTMLReportGenerator();
String baseName = getBaseName(log.getSource());
Path reportDir = outputDir.toPath().resolve(baseName);
reporter.generateReport(result, reportDir);
}
private void generateTextReport(GCLog log, AnalysisResult result) {
// Implementation for text report
String baseName = getBaseName(log.getSource());
Path reportFile = outputDir.toPath().resolve(baseName + "-report.txt");
try (var writer = new java.io.PrintWriter(reportFile.toFile())) {
writer.println("GC Log Analysis Report");
writer.println("======================");
writer.println("Source: " + log.getSource());
writer.println("Total GC Events: " + result.getBasicStatistics().getTotalEvents());
writer.println("Throughput: " + String.format("%.1f%%", result.getThroughput()));
writer.println("Issues Found: " + result.getIssueCount());
writer.println();
if (result.hasIssues()) {
writer.println("Detected Issues:");
writer.println("----------------");
for (String issue : result.getIssues()) {
writer.println("• " + issue);
}
writer.println();
}
} catch (Exception e) {
System.err.println("Failed to generate text report: " + e.getMessage());
}
}
private void generateJSONReport(GCLog log, AnalysisResult result) {
// Implementation for JSON report
String baseName = getBaseName(log.getSource());
Path reportFile = outputDir.toPath().resolve(baseName + "-report.json");
try {
var objectMapper = new com.fasterxml.jackson.databind.ObjectMapper();
objectMapper.writerWithDefaultPrettyPrinter()
.writeValue(reportFile.toFile(), result);
} catch (Exception e) {
System.err.println("Failed to generate JSON report: " + e.getMessage());
}
}
private void printConsoleSummary(AnalysisResult result) {
GCStatistics stats = result.getBasicStatistics();
System.out.println("📊 Analysis Summary:");
System.out.println("   Total events: " + stats.getTotalEvents());
System.out.println("   Young GC: " + stats.getYoungGCCount());
System.out.println("   Full GC: " + stats.getFullGCCount());
System.out.println("   Throughput: " + String.format("%.1f%%", result.getThroughput()));
System.out.println("   Avg pause: " + String.format("%.3fs", stats.getAveragePauseTime()));
System.out.println("   Max pause: " + String.format("%.3fs", stats.getMaxGCPause()));
System.out.println("   Issues: " + result.getIssueCount());
if (result.hasIssues()) {
System.out.println("   ⚠️  Top issues:");
result.getIssuesBySeverity().stream()
.limit(3)
.forEach(issue -> System.out.println("     • " + issue));
} else {
System.out.println("   ✅ No critical issues detected");
}
}
private String getBaseName(String source) {
String name = new File(source).getName();
int dotIndex = name.lastIndexOf('.');
return dotIndex > 0 ? name.substring(0, dotIndex) : name;
}
public static void main(String[] args) {
int exitCode = new CommandLine(new CLIRunner()).execute(args);
System.exit(exitCode);
}
}

Usage Examples

// Programmatic usage
public class ExampleUsage {
public static void main(String[] args) throws Exception {
GCLogParser parser = new GCLogParser();
GCLog log = parser.parseFromFile(Paths.get("gc.log"));
GCLogAnalyzer analyzer = new GCLogAnalyzer(log);
AnalysisResult result = analyzer.analyze();
HTMLReportGenerator reporter = new HTMLReportGenerator();
reporter.generateReport(result, Paths.get("reports"));
System.out.println("Analysis complete. Found " + result.getIssueCount() + " issues.");
System.out.println("Throughput: " + String.format("%.1f%%", result.getThroughput()));
}
}
// CLI Usage
// java -jar gcanalyzer.jar gc.log -o ./reports --format HTML --verbose

Features

✅ Comprehensive Parsing

  • Support for all major GC collectors (G1, CMS, Parallel, Serial, ZGC, Shenandoah)
  • Unified logging format (Java 9+)
  • Classic GC logging format
  • Automatic collector detection

✅ Advanced Analysis

  • Throughput calculation and analysis
  • Pause time statistics and percentiles
  • Memory usage patterns
  • GC efficiency metrics
  • Allocation rate analysis

✅ Issue Detection

  • Long pause detection
  • Frequent GC detection
  • Memory pressure identification
  • Throughput issues
  • Collector-specific problems

✅ Visual Reporting

  • Interactive HTML reports with charts
  • Executive summaries
  • Detailed statistics tables
  • Actionable recommendations
  • Performance trends

This GC log analyzer provides enterprise-grade analysis capabilities for identifying and diagnosing garbage collection issues in Java applications, with comprehensive reporting and advanced detection algorithms.

Category : JAVA

Leave a Reply

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


Macro Nepal Helper