fix: Make SentryBreadcrumb thread-safe to prevent crashes in addBreadcrumb (#7665)

* fix: Make SentryBreadcrumb thread-safe to prevent crashes in addBreadcrumb

SentryBreadcrumb properties were nonatomic with no synchronization, and the data property used strong instead of copy. This caused EXC_BAD_ACCESS crashes when serialize read properties concurrently with writes, or when mutable objects nested in data were mutated while sentry_sanitize iterated them.

- Add @synchronized(self) to all property accessors and serialize
- Deep-copy data in the setter so the SDK never holds references to caller-owned mutable collections
- Add defensive [copy] in sentry_sanitize and sanitizeArray before iterating
- Replace SENTRY_LOG_DEBUG(@"Add breadcrumb: %@", crumb) with category/message to avoid triggering full serialization on every addBreadcrumb

Fixes #2601

Author: denrase

CHANGELOG.md

@@ -6,6 +6,10 @@
 
 - Add `SentrySDK.lastRunStatus` to distinguish unknown, no-crash and crash (#7469)
 
+### Fixes
+
+- Make SentryBreadcrumb thread-safe to prevent crashes in addBreadcrumb ([#7665](https://github.com/getsentry/sentry-cocoa/pull/7665))
+
 ## 9.7.0
 
 ### Features

Sources/Sentry/Public/SentryBreadcrumb.h

@@ -49,7 +49,7 @@ NS_SWIFT_NAME(Breadcrumb)
 /**
  * Arbitrary additional data that will be sent with the breadcrumb
  */
-@property (nonatomic, strong, nullable) NSDictionary<NSString *, id> *data;
+@property (nonatomic, copy, nullable) NSDictionary<NSString *, id> *data;
 
 /**
  * Initializer for @c SentryBreadcrumb

Sources/Sentry/SentryArray.m

@@ -7,8 +7,11 @@ @implementation SentryArray
 
 + (NSArray *)sanitizeArray:(NSArray *)array;
 {
+    // Defensive copy to prevent mutation during enumeration.
+    NSArray *arrayCopy = [array copy];
+
     NSMutableArray *result = [NSMutableArray array];
-    for (id rawValue in array) {
+    for (id rawValue in arrayCopy) {
         if ([rawValue isKindOfClass:NSString.class]) {
             [result addObject:rawValue];
         } else if ([rawValue isKindOfClass:NSNumber.class]) {

Sources/Sentry/SentryBreadcrumb.m

@@ -7,8 +7,154 @@
 #import "SentryNSDictionarySanitize.h"
 #import "SentrySwift.h"
 
+/**
+ * Recursively copies a value, producing immutable collections at every level.
+ * For @c NSDictionary / @c NSArray (including mutable subclasses) a new immutable copy is
+ * returned with all nested containers copied as well. Other values are returned as-is.
+ * This prevents the SDK from holding references to caller-owned mutable objects whose
+ * concurrent mutation would crash serialization (see
+ * https://github.com/getsentry/sentry-cocoa/issues/2601).
+ */
+static id
+sentry_deepCopyValue(id value)
+{
+    if ([value isKindOfClass:[NSDictionary class]]) {
+        // Defensive copy to prevent mutation during enumeration.
+        NSDictionary *dictionaryCopy = [(NSDictionary *)value copy];
+        NSMutableDictionary *result =
+            [NSMutableDictionary dictionaryWithCapacity:dictionaryCopy.count];
+        for (id key in dictionaryCopy) {
+            id v = dictionaryCopy[key];
+            if (v != nil) {
+                result[key] = sentry_deepCopyValue(v);
+            }
+        }
+        return [result copy]; // immutable
+    } else if ([value isKindOfClass:[NSArray class]]) {
+        // Defensive copy to prevent mutation during enumeration.
+        NSArray *arrayCopy = [(NSArray *)value copy];
+        NSMutableArray *result = [NSMutableArray arrayWithCapacity:arrayCopy.count];
+        for (id item in arrayCopy) {
+            [result addObject:sentry_deepCopyValue(item)];
+        }
+        return [result copy]; // immutable
+    }
+    return value;
+}
+
 @implementation SentryBreadcrumb
 
+// Explicit @synthesize so we can provide thread-safe accessors via @synchronized(self).
+@synthesize level = _level;
+@synthesize category = _category;
+@synthesize timestamp = _timestamp;
+@synthesize type = _type;
+@synthesize message = _message;
+@synthesize origin = _origin;
+@synthesize data = _data;
+
+#pragma mark - Thread-safe property accessors
+
+- (void)setLevel:(SentryLevel)level
+{
+    @synchronized(self) {
+        _level = level;
+    }
+}
+
+- (SentryLevel)level
+{
+    @synchronized(self) {
+        return _level;
+    }
+}
+
+- (void)setCategory:(NSString *)category
+{
+    @synchronized(self) {
+        _category = [category copy];
+    }
+}
+
+- (NSString *)category
+{
+    @synchronized(self) {
+        return _category;
+    }
+}
+
+- (void)setTimestamp:(NSDate *)timestamp
+{
+    @synchronized(self) {
+        _timestamp = timestamp;
+    }
+}
+
+- (NSDate *)timestamp
+{
+    @synchronized(self) {
+        return _timestamp;
+    }
+}
+
+- (void)setType:(NSString *)type
+{
+    @synchronized(self) {
+        _type = [type copy];
+    }
+}
+
+- (NSString *)type
+{
+    @synchronized(self) {
+        return _type;
+    }
+}
+
+- (void)setMessage:(NSString *)message
+{
+    @synchronized(self) {
+        _message = [message copy];
+    }
+}
+
+- (NSString *)message
+{
+    @synchronized(self) {
+        return _message;
+    }
+}
+
+- (void)setOrigin:(NSString *)origin
+{
+    @synchronized(self) {
+        _origin = [origin copy];
+    }
+}
+
+- (NSString *)origin
+{
+    @synchronized(self) {
+        return _origin;
+    }
+}
+
+- (void)setData:(NSDictionary<NSString *, id> *)data
+{
+    @synchronized(self) {
+        _data = data ? sentry_deepCopyValue(data) : nil;
+    }
+}
+
+- (NSDictionary<NSString *, id> *)data
+{
+    @synchronized(self) {
+        return _data;
+    }
+}
+
+#pragma mark - Initializers
+
 - (instancetype)initWithDictionary:(NSDictionary *)dictionary
 {
     if (self = [super init]) {
@@ -56,24 +202,46 @@ - (instancetype)init
     return [self initWithLevel:kSentryLevelInfo category:@"default"];
 }
 
+#pragma mark - Serialization
+
 - (NSDictionary<NSString *, id> *)serialize
 {
+    // Capture all properties under the lock to get a consistent snapshot.
+    SentryLevel level;
+    NSDate *timestamp;
+    NSString *category;
+    NSString *type;
+    NSString *origin;
+    NSString *message;
+    NSDictionary *data;
+
+    @synchronized(self) {
+        level = _level;
+        timestamp = _timestamp;
+        category = _category;
+        type = _type;
+        origin = _origin;
+        message = _message;
+        data = _data;
+    }
+
     NSMutableDictionary *serializedData = [[NSMutableDictionary alloc] init];
 
-    [serializedData setValue:nameForSentryLevel(self.level) forKey:@"level"];
-    if (self.timestamp != nil) {
-        [serializedData
-            setValue:sentry_toIso8601String(SENTRY_UNWRAP_NULLABLE(NSDate, self.timestamp))
-              forKey:@"timestamp"];
-    }
-    [serializedData setValue:self.category forKey:@"category"];
-    [serializedData setValue:self.type forKey:@"type"];
-    [serializedData setValue:self.origin forKey:@"origin"];
-    [serializedData setValue:self.message forKey:@"message"];
-    [serializedData setValue:sentry_sanitize(self.data) forKey:@"data"];
+    [serializedData setValue:nameForSentryLevel(level) forKey:@"level"];
+    if (timestamp != nil) {
+        [serializedData setValue:sentry_toIso8601String(SENTRY_UNWRAP_NULLABLE(NSDate, timestamp))
+                          forKey:@"timestamp"];
+    }
+    [serializedData setValue:category forKey:@"category"];
+    [serializedData setValue:type forKey:@"type"];
+    [serializedData setValue:origin forKey:@"origin"];
+    [serializedData setValue:message forKey:@"message"];
+    [serializedData setValue:sentry_sanitize(data) forKey:@"data"];
     return serializedData;
 }
 
+#pragma mark - Equality
+
 - (BOOL)isEqual:(id _Nullable)other
 {
     if (other == self)

Sources/Sentry/SentryNSDictionarySanitize.m

@@ -12,9 +12,12 @@
         return nil;
     }
 
+    // Defensive copy to prevent mutation during enumeration.
+    NSDictionary *dictionaryCopy = [dictionary copy];
+
     NSMutableDictionary *dict = [NSMutableDictionary dictionary];
-    for (id rawKey in dictionary.allKeys) {
-        id rawValue = [dictionary objectForKey:rawKey];
+    for (id rawKey in dictionaryCopy.allKeys) {
+        id rawValue = [dictionaryCopy objectForKey:rawKey];
 
         NSString *stringKey;
         if ([rawKey isKindOfClass:NSString.class]) {

Sources/Sentry/SentryScope.m

@@ -102,7 +102,7 @@ - (void)addBreadcrumb:(SentryBreadcrumb *)crumb
     if (self.maxBreadcrumbs < 1) {
         return;
     }
-    SENTRY_LOG_DEBUG(@"Add breadcrumb: %@", crumb);
+    SENTRY_LOG_DEBUG(@"Add breadcrumb: %@ - %@", crumb.category, crumb.message);
     @synchronized(_breadcrumbArray) {
         // Use a ring buffer making adding breadcrumbs O(1).
         // In a prior version, we added the new breadcrumb at the end of the array and used