introducing Sentry Logging

Author: teg-atlassian

.env.example

@@ -11,7 +11,7 @@ ATLASCODE_FX3_TIMEOUT="2000"
 #
 
 # Syntax: comma separated settings in the format <name>=<boolean>
-ATLASCODE_FF_OVERRIDES="feature_flag_1=true, feature_flag_2=false"
+ATLASCODE_FF_OVERRIDES="atlascode-sentry-logging=true, feature_flag_2=false"
 
 # This is for experiments that controls a boolean value.
 # Syntax: comma separated settings in the format <name>=<boolean>
@@ -20,4 +20,13 @@ ATLASCODE_EXP_OVERRIDES_BOOL="exp1_name=true, exp2_name=false"
 # This is for experiments that controls a string value.
 # Syntax: comma separated settings in the format <name>=<string>
 # NOTE: the string is unquoted, and a comma within the string is not supported.
-ATLASCODE_EXP_OVERRIDES_STRING="exp3_name=something, exp4_name=something else"
+ATLASCODE_EXP_OVERRIDES_STRING="exp3_name=something, exp4_name=something else"
+
+#
+# Sentry Error Tracking Configuration (optional)
+# Only set these values if you want to enable Sentry error tracking
+#
+SENTRY_ENABLED=false
+SENTRY_DSN=https://example.com
+SENTRY_ENVIRONMENT=production
+SENTRY_SAMPLE_RATE=1.0

package-lock.json

@@ -1670,6 +1670,8 @@
         "@mui/styles": "^5.18.0",
         "@mui/utils": "^5.17.1",
         "@segment/analytics-node": "^2.1.3",
+        "@sentry/browser": "^9.40.0",
+        "@sentry/node": "^9.40.0",
         "@speed-highlight/core": "^1.2.7",
         "@vscode/codicons": "^0.0.40",
         "@vscode/webview-ui-toolkit": "^1.4.0",

package.json

@@ -40,6 +40,7 @@ import { RovoDevCodeActionProvider } from './rovo-dev/rovoDevCodeActionProvider'
 import { RovoDevProcessManager } from './rovo-dev/rovoDevProcessManager';
 import { RovoDevWebviewProvider } from './rovo-dev/rovoDevWebviewProvider';
 import { RovoDevLogger } from './rovo-dev/util/rovoDevLogger';
+import { SentryConfig, SentryService } from './sentry';
 import { SiteManager } from './siteManager';
 import { AtlascodeUriHandler, SETTINGS_URL } from './uriHandler';
 import { Experiments, FeatureFlagClient, FeatureFlagClientInitError, Features } from './util/featureFlags';
@@ -260,6 +261,25 @@ export class Container {
         this._onboardingProvider = new OnboardingProvider();
 
         this.refreshRovoDev(context);
+
+        // Initialize Sentry for error tracking
+        try {
+            const sentryConfig: SentryConfig = {
+                enabled: process.env.SENTRY_ENABLED === 'true',
+                dsn: process.env.SENTRY_DSN,
+                environment: process.env.SENTRY_ENVIRONMENT || 'development',
+                sampleRate: parseFloat(process.env.SENTRY_SAMPLE_RATE || '1.0'),
+                atlasCodeVersion: version,
+            };
+
+            if (sentryConfig.enabled && sentryConfig.dsn) {
+                await SentryService.getInstance().initialize(sentryConfig);
+                Logger.info('Sentry initialized successfully');
+            }
+        } catch (error) {
+            Logger.error(error as Error, 'Failed to initialize Sentry');
+            // Continue with extension startup regardless
+        }
     }
 
     private static async initializeFeatureFlagClient() {

src/container.ts

@@ -33,6 +33,13 @@ jest.mock('./container', () => ({
     },
 }));
 
+// Mock SentryService
+jest.mock('./sentry', () => ({
+    SentryService: {
+        getInstance: jest.fn(),
+    },
+}));
+
 const mockContainerIsDebugging = () => {
     (Container.isDebugging as any) = true;
 };
@@ -50,6 +57,13 @@ describe('Logger', () => {
         // Reset mocks
         jest.clearAllMocks();
 
+        // Setup default SentryService mock to avoid crashes in other tests
+        const { SentryService } = require('./sentry');
+        (SentryService.getInstance as jest.Mock).mockReturnValue({
+            isInitialized: jest.fn().mockReturnValue(false),
+            captureException: jest.fn(),
+        });
+
         mockOutputChannel = expansionCastTo<LogOutputChannel>({
             dispose: jest.fn(),
             append: jest.fn(),
@@ -323,4 +337,100 @@ describe('Logger', () => {
             }
         });
     });
+
+    describe('Sentry integration', () => {
+        let mockSentryService: any;
+
+        beforeEach(() => {
+            // Set up Logger with Error level
+            (configuration.initializing as jest.Mock).mockReturnValue(true);
+            (configuration.get as jest.Mock).mockReturnValue(OutputLevel.Errors);
+            Logger.configure(expansionCastTo<ExtensionContext>({ subscriptions: [] }));
+
+            // Setup the mocked Sentry service to be returned by getInstance
+            mockSentryService = {
+                isInitialized: jest.fn(),
+                captureException: jest.fn(),
+            };
+            const { SentryService } = require('./sentry');
+            (SentryService.getInstance as jest.Mock).mockReturnValue(mockSentryService);
+            mockSentryService.isInitialized.mockReturnValue(true);
+        });
+
+        it('should not capture exception to Sentry when not initialized', () => {
+            mockSentryService.isInitialized.mockReturnValue(false);
+
+            const testError = new Error('test error');
+            Logger.error(testError, 'Error message');
+
+            expect(mockSentryService.captureException).not.toHaveBeenCalled();
+        });
+
+        it('should include capturedBy in Sentry tags', () => {
+            mockSentryService.isInitialized.mockReturnValue(true);
+
+            const testError = new Error('test error');
+            Logger.error(testError, 'Error message');
+
+            expect(mockSentryService.captureException).toHaveBeenCalledWith(
+                testError,
+                expect.objectContaining({
+                    tags: expect.objectContaining({
+                        capturedBy: expect.any(String),
+                    }),
+                }),
+            );
+        });
+
+        it('should include params in Sentry extra context', () => {
+            mockSentryService.isInitialized.mockReturnValue(true);
+
+            const testError = new Error('test error');
+            Logger.error(testError, 'Error message', 'param1', 'param2');
+
+            expect(mockSentryService.captureException).toHaveBeenCalledWith(
+                testError,
+                expect.objectContaining({
+                    extra: expect.objectContaining({
+                        params: ['param1', 'param2'],
+                    }),
+                }),
+            );
+        });
+
+        it('should handle Sentry errors gracefully and continue logging', () => {
+            mockSentryService.isInitialized.mockReturnValue(true);
+            mockSentryService.captureException.mockImplementation(() => {
+                throw new Error('Sentry failed');
+            });
+
+            const testError = new Error('test error');
+
+            // Should not throw
+            expect(() => {
+                Logger.error(testError, 'Error message');
+            }).not.toThrow();
+
+            // Should still log to output channel
+            expect(mockOutputChannel.appendLine).toHaveBeenCalled();
+        });
+
+        it('should call Sentry before logging to output channel', () => {
+            mockSentryService.isInitialized.mockReturnValue(true);
+            const callOrder: string[] = [];
+
+            mockSentryService.captureException.mockImplementation(() => {
+                callOrder.push('sentry');
+            });
+
+            (mockOutputChannel.appendLine as jest.Mock).mockImplementation(() => {
+                callOrder.push('output');
+            });
+
+            const testError = new Error('test error');
+            Logger.error(testError, 'Error message');
+
+            expect(callOrder).toEqual(['sentry', 'output']);
+        });
+    });
 });

src/logger.test.ts

@@ -156,6 +156,25 @@ export class Logger {
     ): void {
         Logger._onError.fire({ error: ex, errorMessage, capturedBy, params, productArea });
 
+        // Capture to Sentry if initialized
+        try {
+            const { SentryService } = require('./sentry');
+            if (SentryService.getInstance().isInitialized()) {
+                SentryService.getInstance().captureException(ex, {
+                    tags: {
+                        productArea: productArea || 'unknown',
+                        capturedBy: capturedBy || 'unknown',
+                    },
+                    extra: {
+                        errorMessage,
+                        params,
+                    },
+                });
+            }
+        } catch (e) {
+            console.error('Failed to initialize Sentry:', e);
+        }
+
         if (this.level === OutputLevel.Silent) {
             return;
         }