Feat: Add export functionality

[asungur]

• Create export.go with ExportFormat enum
• Implement JSON export
• Implement CSV export (with tag/data flattening)
• Test export output correctness

[claude]

Pull Request Review: Export Functionality

Thank you for this PR! The export functionality is well-structured and follows good Go practices. Below is my detailed review.

✅ Strengths

1. Clean API Design: The Export method follows the existing codebase patterns with context support and proper error handling
2. Comprehensive Testing: Excellent test coverage including edge cases (empty DB, multiple events, various data types)
3. Code Organization: Well-structured helper functions with clear separation of concerns
4. Consistency: Follows existing patterns from query.go and aggregation.go (context checking, RLock usage)
5. CSV Handling: Smart approach to flattening tags and data with sorted keys for deterministic column order

🐛 Potential Issues

1. Context Cancellation in CSV Export (export.go:58-85)

The CSV export doesn't check for context cancellation during iteration. For large datasets, this could prevent timely cancellation.

Suggestion:

// Write rows
for _, event := range events {
    if err := ctx.Err(); err != nil {
        return err
    }
    row := buildCSVRow(event, tagKeys, dataKeys)
    if err := writer.Write(row); err != nil {
        return err
    }
}

2. JSON Export Missing Context Check (export.go:50-54)

Similarly, JSON export should check context before encoding, especially for large event arrays.

Suggestion:

func exportJSON(w io.Writer, events []*Event) error {
    encoder := json.NewEncoder(w)
    encoder.SetIndent("", "  ")
    return encoder.Encode(events)
}

While encoding is typically fast, consider adding a check if len(events) is very large.

3. Timestamp Format Consistency (export.go:139)

The timestamp format uses a custom layout. Consider using RFC3339Nano for standard ISO 8601 compliance:

Current:

event.Timestamp.Format("2006-01-02T15:04:05.000Z07:00")

Suggestion:

event.Timestamp.Format(time.RFC3339Nano)

This ensures better interoperability with other tools and is more idiomatic.

4. Missing Context Parameter in Helper Functions (export.go:58-154)

Helper functions like exportCSV and exportJSON don't receive the context, making it harder to add cancellation checks later.

Suggestion:

func exportJSON(ctx context.Context, w io.Writer, events []*Event) error
func exportCSV(ctx context.Context, w io.Writer, events []*Event) error

🔒 Security Considerations

1. CSV Injection: No issues detected - the csv.Writer properly escapes fields
2. Memory Safety: Good - empty events return early (export.go:60-62)
3. Resource Limits: The Query method is called first, so any limits there apply. Consider documenting this dependency.

⚡ Performance Considerations

1. Memory Allocation (export.go:59-66): The collectKeys and collectDataKeys functions iterate all events twice (once each). For very large exports, consider collecting keys during the row-writing loop.

Current approach:

• Pass 1: Collect tag keys
• Pass 2: Collect data keys
• Pass 3: Write rows

Optimized approach (if needed):

• Pass 1: Collect all keys AND write rows in a single pass using a buffered approach

2. CSV Writer Flushing: Good - defer writer.Flush() is used and writer.Error() is checked (export.go:71, 84)

🧪 Test Coverage

Excellent coverage! The tests include:

• ✅ JSON export correctness
• ✅ CSV export with multiple tags/data fields
• ✅ Empty database handling
• ✅ Query filtering integration
• ✅ Various data types (strings, numbers, booleans, arrays, objects)
• ✅ Multiple events with sparse fields

Missing test cases:

1. Context cancellation: No test for canceling a long-running export
2. Large datasets: No test with many events (though this might be intentional for test speed)
3. Invalid format: No test for an undefined ExportFormat value (though the default case handles it)

Suggested additional test:

func TestExportContextCancellation(t *testing.T) {
    // Insert many events
    // Create a context with timeout or cancel it mid-export
    // Verify export returns context.Canceled or context.DeadlineExceeded
}

📋 Code Quality

1. Documentation: Excellent godoc comments on exported functions
2. Error Messages: Clear and consistent with existing code
3. Naming: Clear and idiomatic Go naming conventions
4. Code Style: Matches existing codebase patterns

🎯 Recommendations

High Priority

1. Add context cancellation checks in exportCSV loop
2. Pass context to helper functions for future-proofing

Medium Priority

3. Use time.RFC3339Nano for timestamp formatting
4. Add context cancellation test

Low Priority

5. Consider performance optimization for very large exports (likely not needed for MVP)

Summary

This is a solid implementation that integrates well with the existing codebase. The code is clean, well-tested, and follows Go best practices. The main suggestions are around context handling for robustness with large datasets.

Recommendation: ✅ Approve with minor suggestions

The issues mentioned are minor and could be addressed in this PR or as follow-up improvements. The functionality is production-ready as-is for typical use cases.