fix(core): Only consider exception mechanism when updating session status from event with exceptions (#18137)

This PR fixes an oversight in our session update logic when we update
the SDK's session status while processing an error event. Previously,
we'd always set `status: 'crashed'` as soon as the top-level
`event.level` field was set to `'fatal'` (added in
#15072). However,
this disregarded the case where the level was initially `'fatal'` but
later on the SDK or users decided to set the
`event.exceptions.values[i].mechanism.handled` field to `true`.

Simplest reproduction:

```
Sentry.captureException(new Error('test'), { captureContext: { level: 'fatal' } });
```

This PR changes the update logic to only look at the event mechanisms if
the event contained exceptions. I _think_ this is still compatible with
#15072 because the PR suggests we only care about `event.level ===
'fatal'` if no exceptions are on the event. But I'd appreciate a second
pair of eyes on this (cc @timfish).

Author: Lms24

packages/core/src/client.ts

@@ -1037,16 +1037,18 @@ export abstract class Client<O extends ClientOptions = ClientOptions> {
 
   /** Updates existing session based on the provided event */
   protected _updateSessionFromEvent(session: Session, event: Event): void {
+    // initially, set `crashed` based on the event level and update from exceptions if there are any later on
     let crashed = event.level === 'fatal';
     let errored = false;
     const exceptions = event.exception?.values;
 
     if (exceptions) {
       errored = true;
+      // reset crashed to false if there are exceptions, to ensure `mechanism.handled` is respected.
+      crashed = false;
 
       for (const ex of exceptions) {
-        const mechanism = ex.mechanism;
-        if (mechanism?.handled === false) {
+        if (ex.mechanism?.handled === false) {
           crashed = true;
           break;
         }

packages/core/test/lib/client.test.ts

@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, test, vi } from 'vitest';
+import type { SeverityLevel } from '../../src';
 import {
   addBreadcrumb,
   dsnToString,
@@ -2308,6 +2309,108 @@ describe('Client', () => {
     });
   });
 
+  describe('_updateSessionFromEvent()', () => {
+    describe('event has no exceptions', () => {
+      it('sets status to crashed if level is fatal', () => {
+        const client = new TestClient(getDefaultTestClientOptions());
+        const session = makeSession();
+        getCurrentScope().setSession(session);
+
+        client.captureEvent({ message: 'test', level: 'fatal' });
+
+        const updatedSession = client.session;
+
+        expect(updatedSession).toMatchObject({
+          duration: expect.any(Number),
+          errors: 1,
+          init: false,
+          sid: expect.any(String),
+          started: expect.any(Number),
+          status: 'crashed',
+          timestamp: expect.any(Number),
+        });
+      });
+
+      it.each(['error', 'warning', 'log', 'info', 'debug'] as const)(
+        'sets status to ok if level is %s',
+        (level: SeverityLevel) => {
+          const client = new TestClient(getDefaultTestClientOptions());
+          const session = makeSession();
+          getCurrentScope().setSession(session);
+
+          client.captureEvent({ message: 'test', level });
+
+          const updatedSession = client.session;
+
+          expect(updatedSession?.status).toEqual('ok');
+        },
+      );
+    });
+
+    describe('event has exceptions', () => {
+      it.each(['fatal', 'error', 'warning', 'log', 'info', 'debug'] as const)(
+        'sets status ok for handled exceptions and ignores event level %s',
+        (level: SeverityLevel) => {
+          const client = new TestClient(getDefaultTestClientOptions());
+          const session = makeSession();
+          getCurrentScope().setSession(session);
+
+          client.captureException(new Error('test'), { captureContext: { level } });
+
+          const updatedSession = client.session;
+
+          expect(updatedSession?.status).toEqual('ok');
+        },
+      );
+
+      it.each(['fatal', 'error', 'warning', 'log', 'info', 'debug'] as const)(
+        'sets status crashed for unhandled exceptions and ignores event level %s',
+        (level: SeverityLevel) => {
+          const client = new TestClient(getDefaultTestClientOptions());
+          const session = makeSession();
+          getCurrentScope().setSession(session);
+
+          client.captureException(new Error('test'), { captureContext: { level }, mechanism: { handled: false } });
+
+          const updatedSession = client.session;
+
+          expect(updatedSession?.status).toEqual('crashed');
+        },
+      );
+
+      it('sets status crashed if at least one exception is unhandled', () => {
+        const client = new TestClient(getDefaultTestClientOptions());
+        const session = makeSession();
+        getCurrentScope().setSession(session);
+
+        const event: Event = {
+          exception: {
+            values: [
+              {
+                mechanism: { type: 'generic', handled: true },
+              },
+              {
+                mechanism: { type: 'generic', handled: false },
+              },
+              {
+                mechanism: { type: 'generic', handled: true },
+              },
+            ],
+          },
+        };
+
+        client.captureEvent(event);
+
+        const updatedSession = client.session;
+
+        expect(updatedSession).toMatchObject({
+          status: 'crashed',
+          errors: 1, // an event with multiple exceptions still counts as one error in the session
+        });
+      });
+    });
+  });
+
   describe('recordDroppedEvent()/_clearOutcomes()', () => {
     test('records and returns outcomes', () => {
       const options = getDefaultTestClientOptions({ dsn: PUBLIC_DSN });