Merge pull request #2649 from DataDog/hotfix/3.5.1

Merge `hotfix/3.5.1` to `develop`

Co-authored-by: maxep <maxime.epain@datadoghq.com>
Co-authored-by: gh-worker-dd-mergequeue-cf854d[bot] <244855004+gh-worker-dd-mergequeue-cf854d[bot]@users.noreply.github.com>
Co-authored-by: dd-mergequeue[bot] <121105855+dd-mergequeue[bot]@users.noreply.github.com>
Co-authored-by: ncreated <maciek.grzybowski@datadoghq.com>
Co-authored-by: simaoseica-dd <simao.seica@datadoghq.com>
Co-authored-by: mariedm <29802155+mariedm@users.noreply.github.com>

Author: 6 people

CHANGELOG.md

@@ -3,6 +3,10 @@
 - [IMPROVEMENT] Add `DDLogEventUserInfo.anonymousId` property in ObjC API. See [#2640][]
 - [FEATURE] Support manually keeping or dropping a trace. See [#2639][]
 
+# 3.5.1 / 23-01-2025
+
+- [FIX] Fix crash in App Hangs backtrace generation. See [#2647][]
+
 # 3.5.0 / 12-01-2025
 
 - [FEATURE] Report time to initial display (TTID). See [#2517][] [#2464][] 
@@ -1022,6 +1026,7 @@ Release `2.0` introduces breaking changes. Follow the [Migration Guide](MIGRATIO
 [#2614]: https://github.com/DataDog/dd-sdk-ios/pull/2614
 [#2631]: https://github.com/DataDog/dd-sdk-ios/pull/2631
 [#2633]: https://github.com/DataDog/dd-sdk-ios/pull/2633
+[#2647]: https://github.com/DataDog/dd-sdk-ios/pull/2647
 [#2640]: https://github.com/DataDog/dd-sdk-ios/pull/2640
 [#2639]: https://github.com/DataDog/dd-sdk-ios/pull/2639
 

DatadogCore.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name         = "DatadogCore"
-  s.version      = "3.5.0"
+  s.version      = "3.5.1"
   s.summary      = "Official Datadog Swift SDK for iOS."
 
   s.homepage     = "https://www.datadoghq.com"

DatadogCore/Sources/Versioning.swift

@@ -1,3 +1,3 @@
 // GENERATED FILE: Do not edit directly
 
-internal let __sdkVersion = "3.5.0"
+internal let __sdkVersion = "3.5.1"

DatadogCrashReporting.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name         = "DatadogCrashReporting"
-  s.version      = "3.5.0"
+  s.version      = "3.5.1"
   s.summary      = "Official Datadog Crash Reporting SDK for iOS."
 
   s.homepage     = "https://www.datadoghq.com"

DatadogCrashReporting/Sources/KSCrashIntegration/DatadogCrashReportFilter.swift

@@ -37,14 +37,20 @@ internal import KSCrashRecording
 /// If a report cannot be converted (invalid format, missing required fields),
 /// the original report is passed through and an error is provided to the completion handler.
 internal final class DatadogCrashReportFilter: NSObject, CrashReportFilter {
-    // Parse timestamp with fractional seconds support
-    // KSCrash timestamps use ISO8601 format with microsecond precision (e.g., "2025-10-22T14:14:12.007336Z")
+    /// Parse timestamp with fractional seconds support
+    /// KSCrash timestamps use ISO8601 format with microsecond precision (e.g., "2025-10-22T14:14:12.007336Z")
     let dateFormatter = {
         let formatter = ISO8601DateFormatter()
         formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
         return formatter
     }()
 
+    let telemetry: Telemetry
+
+    init(telemetry: Telemetry = NOPTelemetry()) {
+        self.telemetry = telemetry
+    }
+
     /// Filters and converts crash reports to Datadog's format.
     ///
     /// This method processes each report by converting it from KSCrash's format
@@ -152,8 +158,16 @@ internal final class DatadogCrashReportFilter: NSObject, CrashReportFilter {
                     return String(format: "%-4ld ??? 0x%016llx 0x0 + 0", index, instructionAddr)
                 }
 
+                let offset: Int64
+                if instructionAddr >= objectAddr {
+                    offset = instructionAddr - objectAddr
+                } else {
+                    offset = 0
+                    telemetry.error("Invalid image load address, symbolication will fail")
+                }
+
                 // Format: frame_index (4 chars left-aligned) + library_name (35 chars left-aligned) + instruction_addr + image_base_addr + offset
-                return String(format: "%-4ld %-35@ 0x%016llx 0x%016llx + %lld", index, objectName, instructionAddr, objectAddr, instructionAddr - objectAddr)
+                return String(format: "%-4ld %-35@ 0x%016llx 0x%016llx + %lld", index, objectName, instructionAddr, objectAddr, offset)
             }
 
             let index: Int64 = try thread.value(forKey: .index)

DatadogCrashReporting/Sources/KSCrashIntegration/KSCrashBacktrace.swift

@@ -35,7 +35,7 @@ internal struct KSCrashBacktrace: BacktraceReporting {
     func generateBacktrace(threadID: ThreadID) throws -> BacktraceReport? {
         // Convert Mach thread_t to pthread_t
         guard let pthread = pthread_from_mach_thread_np(threadID) else {
-            telemetry.error("[KSCrashBacktrace] Failed to get pthread for thread with ID: \(threadID)")
+            telemetry.error("Failed to get pthread for thread with ID: \(threadID)")
             return nil
         }
 
@@ -66,6 +66,14 @@ internal struct KSCrashBacktrace: BacktraceReporting {
             let loadAddress = binaryImage.address
             let uuid = UUID(uuid: imageUUID.withMemoryRebound(to: uuid_t.self, capacity: 1) { $0.pointee })
 
+            let offset: UInt64
+            if address >= loadAddress {
+                offset = UInt64(address) - loadAddress
+            } else {
+                offset = 0
+                telemetry.error("Invalid image load address, symbolication will fail")
+            }
+
             // Get architecture from binary image's CPU type
             let architecture = String(cString: kscpu_archForCPU(
                 cpu_type_t(binaryImage.cpuType),
@@ -84,7 +92,7 @@ internal struct KSCrashBacktrace: BacktraceReporting {
             }
 
             // Format: frame_index (4 chars left-aligned) + library_name (35 chars left-aligned) + addresses + offset
-            return String(format: "%-4ld %-35@ 0x%016llx 0x%016llx + %lld", index, libraryName, address, loadAddress, UInt64(address) - loadAddress)
+            return String(format: "%-4ld %-35@ 0x%016llx 0x%016llx + %lld", index, libraryName, address, loadAddress, offset)
         }
         .joined(separator: "\n")
 
@@ -108,7 +116,7 @@ internal struct KSCrashBacktrace: BacktraceReporting {
     private func getThreadName(pthread: pthread_t) -> String? {
         var buffer = [CChar](repeating: 0, count: 256)
         guard pthread_getname_np(pthread, &buffer, buffer.count) == KERN_SUCCESS, buffer[0] != 0 else {
-            telemetry.error("[KSCrashBacktrace] Failed to get pthread name")
+            telemetry.error("Failed to get pthread name")
             return nil // fails or empty
         }
         return String(cString: buffer)
@@ -124,16 +132,19 @@ internal struct KSCrashBacktrace: BacktraceReporting {
 /// This allows us to determine the correct architecture (arm64, arm64e, etc.) for each
 /// binary image, which is critical for accurate stacktrace symbolication.
 private func symbolicate(address: uintptr_t) -> KSBinaryImage? {
-    // initalize the binary image cache.
-    // this has an atomic check so isn't expensive
-    // except for the first call.
-    ksbic_init()
-
     let untaggedAddress = kssymbolicator_callInstructionAddress(address)
-
+    let instructionPointer = UnsafeRawPointer(bitPattern: untaggedAddress)
+
+    // Use standard dladdr() instead of ksdl_dladdr() to work around a bug where ksdl_dladdr()
+    // can return the wrong image when looking up addresses in the presence of dynamic
+    // frameworks. The bug causes unsigned arithmetic underflow when calculating the
+    // instruction offset.
+    //
+    // This was fixed in KSCrash and is currently pending release.
+    // See: https://github.com/DataDog/dd-sdk-ios/issues/2645
     var info = Dl_info()
     guard
-        ksdl_dladdr(untaggedAddress, &info),
+        dladdr(instructionPointer, &info) != 0,
         let baseAddress = info.dli_fbase,
         let fileName = info.dli_fname
     else {

DatadogCrashReporting/Sources/KSCrashIntegration/KSCrashPlugin.swift

@@ -34,7 +34,7 @@ internal class KSCrashPlugin: NSObject, CrashReportingPlugin {
                     DatadogTypeSafeFilter(),
                     DatadogMinifyFilter(),
                     DatadogDiagnosticFilter(),
-                    DatadogCrashReportFilter()
+                    DatadogCrashReportFilter(telemetry: telemetry)
                 ]
             )
         } catch KSCrashInstallError.alreadyInstalled {

DatadogCrashReporting/Tests/KSCrashIntegration/DatadogCrashReportFilterTests.swift

@@ -476,4 +476,67 @@ class DatadogCrashReportFilterTests: XCTestCase {
         XCTAssertEqual(ddReport1.meta.incidentIdentifier, "1")
         XCTAssertEqual(ddReport2.meta.incidentIdentifier, "2")
     }
+
+    func testFilterReports_HandlesInvalidOffsetCalculation() throws {
+        // Given - instruction_addr less than object_addr (should not happen in practice)
+        let json = """
+        {
+            "report": {
+                "timestamp": "2025-10-22T14:14:12Z",
+                "id": "incident-invalid-offset"
+            },
+            "system": {
+                "cpu_arch": "arm64"
+            },
+            "crash": {
+                "error": {
+                    "signal": {
+                        "name": "SIGSEGV"
+                    }
+                },
+                "threads": [
+                    {
+                        "index": 0,
+                        "crashed": true,
+                        "backtrace": {
+                            "contents": [
+                                {
+                                    "instruction_addr": 1000,
+                                    "object_addr": 5000,
+                                    "object_name": "MyApp"
+                                }
+                            ]
+                        }
+                    }
+                ]
+            },
+            "binary_images": []
+        }
+        """.data(using: .utf8)!
+
+        let dict = try XCTUnwrap(JSONSerialization.jsonObject(with: json) as? [String: Any])
+        let report = AnyCrashReport(CrashFieldDictionary(from: dict))
+        let filter = DatadogCrashReportFilter()
+        var capturedReports: [CrashReport]?
+
+        // When
+        filter.filterReports([report]) { reports, error in
+            XCTAssertNil(error)
+            capturedReports = reports
+        }
+
+        // Then
+        let ddReport = try XCTUnwrap(capturedReports?.first?.untypedValue as? DDCrashReport)
+
+        // Verify stack format using regex parser
+        let stackLines = ddReport.stack.split(separator: "\n")
+        XCTAssertEqual(stackLines.count, 1, "Should have 1 stack frame")
+
+        let parsed = try parseStackFrame(String(stackLines[0]))
+        XCTAssertEqual(parsed.index, 0)
+        XCTAssertEqual(parsed.libraryName, "MyApp")
+        XCTAssertEqual(parsed.instructionAddr, "0x00000000000003e8")
+        XCTAssertEqual(parsed.loadAddr, "0x0000000000001388")
+        XCTAssertEqual(parsed.offset, 0, "Offset should be 0 when instruction_addr < object_addr (prevents underflow)")
+    }
 }

DatadogFlags.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name         = "DatadogFlags"
-  s.version      = "3.5.0"
+  s.version      = "3.5.1"
   s.summary      = "Official Datadog Feature Flags module of the Swift SDK."
 
   s.homepage     = "https://www.datadoghq.com"

DatadogInternal.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name         = "DatadogInternal"
-  s.version      = "3.5.0"
+  s.version      = "3.5.1"
   s.summary      = "Datadog Internal Package. This module is not for public use."
 
   s.homepage     = "https://www.datadoghq.com"