refactor: Migrate SentryMsgPackSerializer from Objective-C to Swift

SentryTestUtils/TestStreamableObject.swift

@@ -0,0 +1,78 @@
+@testable import Sentry
+
+private class ErrorInputStream: InputStream {
+    override var hasBytesAvailable: Bool {
+        return true
+    }
+
+    override func read(_ buffer: UnsafeMutablePointer<UInt8>, maxLength len: Int) -> Int {
+        return -1 // Simulate read error
+    }
+
+    override func open() {
+        // No-op
+    }
+
+    override func close() {
+        // No-op
+    }
+}
+
+public class TestStreamableObject: NSObject, SentryStreamable {
+
+    private let shouldReturnNilInputStream: Bool
+    private let streamSizeValue: UInt?
+    private let shouldReturnErrorStream: Bool
+
+    public init(streamSize: UInt?, shouldReturnNilInputStream: Bool, shouldReturnErrorStream: Bool = false) {
+        self.streamSizeValue = streamSize
+        self.shouldReturnNilInputStream = shouldReturnNilInputStream
+        self.shouldReturnErrorStream = shouldReturnErrorStream
+        super.init()
+    }
+
+    public func asInputStream() -> InputStream? {
+        if shouldReturnNilInputStream {
+            return nil
+        }
+        if shouldReturnErrorStream {
+            return ErrorInputStream()
+        }
+        return InputStream(data: Data())
+    }
+
+    public func streamSize() -> UInt? {
+        return streamSizeValue
+    }
+
+    // MARK: - Convenience factory methods for common test scenarios
+
+    public static func objectWithNilInputStream() -> TestStreamableObject {
+        return TestStreamableObject(streamSize: 10, shouldReturnNilInputStream: true)
+    }
+
+    public static func objectWithZeroSize() -> TestStreamableObject {
+        return TestStreamableObject(streamSize: 0, shouldReturnNilInputStream: false)
+    }
+
+    public static func objectWithNegativeSize() -> TestStreamableObject {
+        return TestStreamableObject(streamSize: nil, shouldReturnNilInputStream: false)
+    }
+
+    public static func objectWithErrorStream() -> TestStreamableObject {
+        return TestStreamableObject(streamSize: 10, shouldReturnNilInputStream: false, shouldReturnErrorStream: true)
+    }
+
+    public static func objectWithZeroBytesRead() -> TestStreamableObject {
+        return TestStreamableObject(streamSize: 10, shouldReturnNilInputStream: false, shouldReturnErrorStream: false)
+    }
+
+    public static func objectWithLargeSize() -> TestStreamableObject {
+        // Return size larger than UInt32.max to test truncation
+        return TestStreamableObject(
+            streamSize: UInt.max,
+            shouldReturnNilInputStream: false,
+            shouldReturnErrorStream: false
+        )
+    }
+}

Sources/Sentry/SentryClient.m

@@ -21,7 +21,6 @@
 #import "SentryMechanismMeta.h"
 #import "SentryMessage.h"
 #import "SentryMeta.h"
-#import "SentryMsgPackSerializer.h"
 #import "SentryNSDictionarySanitize.h"
 #import "SentryNSError.h"
 #import "SentryOptions+Private.h"

Sources/Sentry/include/SentryPrivate.h

@@ -36,7 +36,6 @@
 #import "SentryLevelHelper.h"
 #import "SentryMeta.h"
 #import "SentryModels+Serializable.h"
-#import "SentryMsgPackSerializer.h"
 #import "SentryNSDictionarySanitize.h"
 #import "SentryOptions+Private.h"
 #import "SentryProfiler+Private.h"

Sources/Swift/Tools/MsgPack/Data+SentryStreamable.swift

@@ -0,0 +1,9 @@
+extension Data: SentryStreamable {
+    func asInputStream() -> InputStream? {
+        return InputStream(data: self)
+    }
+
+    func streamSize() -> UInt? {
+        return UInt(self.count)
+    }
+}

Sources/Swift/Tools/MsgPack/SentryMsgPackSerializer.swift

@@ -0,0 +1,98 @@
+/**
+ * This is a partial implementation of the MessagePack format.
+ * We only need to concatenate a list of NSData into an envelope item.
+ */
+class SentryMsgPackSerializer {
+    @objc
+    static func serializeDictionary(toMessagePack dictionary: [String: Any], intoFile fileURL: URL) -> Bool {
+        do {
+            let data = try serializeDictionaryToMessagePack(dictionary)
+            try data.write(to: fileURL)
+            return true
+        } catch {
+            SentrySDKLog.error("Failed to serialize dictionary to MessagePack or write to file - Error: \(error)")
+            return false
+        }
+    }
+
+    static func serializeDictionaryToMessagePack(_ dictionary: [String: Any]) throws -> Data { // swiftlint:disable:this function_body_length
+        let outputStream = OutputStream.toMemory()
+        outputStream.open()
+        defer { outputStream.close() }
+
+        let mapHeader = UInt8(0x80 | dictionary.count) // Map up to 15 elements
+        _ = outputStream.write([mapHeader], maxLength: 1)
+
+        for (key, anyValue) in dictionary {
+            guard let value = anyValue as? SentryStreamable else {
+                throw SentryMsgPackSerializerError.invalidValue("Value does not conform to SentryStreamable: \(anyValue)")
+            }
+            guard let keyData = key.data(using: .utf8) else {
+                throw SentryMsgPackSerializerError.invalidInput("Could not encode key as UTF-8: \(key)")
+            }
+
+            let str8Header: UInt8 = 0xD9 // String up to 255 characters
+            let keyLength = UInt8(truncatingIfNeeded: keyData.count) // Truncates if > 255, matching Objective-C behavior
+            _ = outputStream.write([str8Header], maxLength: 1)
+            _ = outputStream.write([keyLength], maxLength: 1)
+
+            try keyData.withUnsafeBytes { bytes in
+                guard let bufferAddress = bytes.bindMemory(to: UInt8.self).baseAddress else {
+                    throw SentryMsgPackSerializerError.invalidInput("Could not get buffer address for key: \(key)")
+                }
+                _ = outputStream.write(bufferAddress, maxLength: keyData.count)
+            }
+
+            guard let dataLength = value.streamSize(), dataLength > 0 else {
+                // MsgPack is being used strictly for session replay.
+                // An item with a length of 0 will not be useful.
+                // If we plan to use MsgPack for something else,
+                // this needs to be re-evaluated.
+                SentrySDKLog.error("Data for MessagePack dictionary has no content - Input: \(value)")
+                throw SentryMsgPackSerializerError.emptyData("Empty data for MessagePack dictionary")
+            }
+
+            let valueLength = UInt32(truncatingIfNeeded: dataLength)
+            // We will always use the 4 bytes data length for simplicity.
+            // Worst case we're losing 3 bytes.
+            let bin32Header: UInt8 = 0xC6
+            _ = outputStream.write([bin32Header], maxLength: 1)
+
+            // Write UInt32 as big endian bytes
+            let lengthBytes = [
+                UInt8((valueLength >> 24) & 0xFF),
+                UInt8((valueLength >> 16) & 0xFF),
+                UInt8((valueLength >> 8) & 0xFF),
+                UInt8(valueLength & 0xFF)
+            ]
+            _ = outputStream.write(lengthBytes, maxLength: 4)
+
+            guard let inputStream = value.asInputStream() else {
+                SentrySDKLog.error("Could not get input stream - Input: \(value)")
+                throw SentryMsgPackSerializerError.streamError("Could not get input stream from value")
+            }
+
+            inputStream.open()
+            defer { inputStream.close() }
+
+            var buffer = [UInt8](repeating: 0, count: 1_024)
+            var bytesRead: Int
+
+            while inputStream.hasBytesAvailable {
+                bytesRead = inputStream.read(&buffer, maxLength: buffer.count)
+                if bytesRead > 0 {
+                    _ = outputStream.write(buffer, maxLength: bytesRead)
+                } else if bytesRead < 0 {
+                    SentrySDKLog.error("Error reading bytes from input stream - Input: \(value) - \(bytesRead)")
+                    throw SentryMsgPackSerializerError.streamError("Error reading bytes from input stream")
+                }
+            }
+        }
+
+        guard let data = outputStream.property(forKey: .dataWrittenToMemoryStreamKey) as? Data else {
+            throw SentryMsgPackSerializerError.outputError("Could not retrieve data from memory stream")
+        }
+
+        return data
+    }
+}

Sources/Swift/Tools/MsgPack/SentryMsgPackSerializerError.swift

@@ -0,0 +1,8 @@
+enum SentryMsgPackSerializerError: Error {
+    case dictionaryTooLarge
+    case invalidValue(String)
+    case invalidInput(String)
+    case emptyData(String)
+    case streamError(String)
+    case outputError(String)
+}

Sources/Swift/Tools/MsgPack/SentryStreamable.swift

@@ -0,0 +1,4 @@
+protocol SentryStreamable {
+    func asInputStream() -> InputStream?
+    func streamSize() -> UInt?
+}

Sources/Swift/Tools/MsgPack/URL+SentryStreamable.swift

@@ -0,0 +1,20 @@
+extension URL: SentryStreamable {
+    func asInputStream() -> InputStream? {
+        return InputStream(url: self)
+    }
+
+    func streamSize() -> UInt? {
+        let attributes: [FileAttributeKey: Any]
+        do {
+            attributes = try FileManager.default.attributesOfItem(atPath: path)
+        } catch {
+            SentrySDKLog.error("Could not read file attributes - File: \(self) - Error: \(error)")
+            return nil
+        }
+        guard let fileSize = attributes[.size] as? NSNumber else {
+            SentrySDKLog.error("Could not read file size attribute - File: \(self)")
+            return nil
+        }
+        return fileSize.uintValue
+    }
+}

Sources/Swift/Tools/SentryEnvelopeItem.swift

@@ -165,9 +165,9 @@
         let envelopeContentUrl = video.deletingPathExtension().appendingPathExtension("dat")
 
         let pack: [String: SentryStreamable] = [
-            "replay_event": replayEventData as NSData,
-            "replay_recording": recording as NSData,
-            "replay_video": video as NSURL
+            "replay_event": replayEventData,
+            "replay_recording": recording,
+            "replay_video": video
         ]
         let success = SentryMsgPackSerializer.serializeDictionary(toMessagePack:
             pack,