Allow manually tracked resources to detect first party hosts

First party hosts set by `trackUrlSession` only works for automatically instrumented URLSessions. This allows manual calls to startResourceLoading and stopResourceLoading to detect first party host calls as well.
DataDog · May 2, 2022 · afc8c1c · afc8c1c
1 parent 8c1d293
commit afc8c1c
Show file tree

Hide file tree

Showing 8 changed files with 89 additions and 11 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,6 +1,7 @@
 # Unreleased
 
 * [BUGFIX] Fix rare problem with bringing up the "Local Network Permission" alert. See [#830][]
+* [IMPROVEMENT] Allow manually tracked resources in RUM Sessions to detect first party hosts. 
 
 # 1.11.0-beta1 / 04-26-2022
 

diff --git a/Sources/Datadog/Core/FeaturesConfiguration.swift b/Sources/Datadog/Core/FeaturesConfiguration.swift
@@ -62,6 +62,7 @@ internal struct FeaturesConfiguration {
         let instrumentation: Instrumentation?
         let backgroundEventTrackingEnabled: Bool
         let onSessionStart: RUMSessionListener?
+        let firstPartyHosts: Set<String>
     }
 
     struct URLSessionAutoInstrumentation {
@@ -184,6 +185,14 @@ extension FeaturesConfiguration {
             )
         }
 
+        var sanitizedHosts: Set<String> = []
+        if let firstPartyHosts = configuration.firstPartyHosts {
+            sanitizedHosts = hostsSanitizer.sanitized(
+                hosts: firstPartyHosts,
+                warningMessage: "The first party host configured for Datadog SDK is not valid"
+            )
+        }
+
         if configuration.rumEnabled {
             let instrumentation = RUM.Instrumentation(
                 uiKitRUMViewsPredicate: configuration.rumUIKitViewsPredicate,
@@ -207,7 +216,8 @@ extension FeaturesConfiguration {
                     longTaskEventMapper: configuration.rumLongTaskEventMapper,
                     instrumentation: instrumentation,
                     backgroundEventTrackingEnabled: configuration.rumBackgroundEventTrackingEnabled,
-                    onSessionStart: configuration.rumSessionsListener
+                    onSessionStart: configuration.rumSessionsListener,
+                    firstPartyHosts: sanitizedHosts
                 )
             } else {
                 let error = ProgrammerError(
@@ -220,13 +230,10 @@ extension FeaturesConfiguration {
             }
         }
 
-        if let firstPartyHosts = configuration.firstPartyHosts {
+        if configuration.firstPartyHosts != nil {
             if configuration.tracingEnabled || configuration.rumEnabled {
                 urlSessionAutoInstrumentation = URLSessionAutoInstrumentation(
-                    userDefinedFirstPartyHosts: hostsSanitizer.sanitized(
-                        hosts: firstPartyHosts,
-                        warningMessage: "The first party host configured for Datadog SDK is not valid"
-                    ),
+                    userDefinedFirstPartyHosts: sanitizedHosts,
                     sdkInternalURLs: [
                         logsEndpoint.url,
                         tracesEndpoint.url,

diff --git a/Sources/Datadog/RUM/RUMMonitor/Scopes/RUMScopeDependencies.swift b/Sources/Datadog/RUM/RUMMonitor/Scopes/RUMScopeDependencies.swift
@@ -23,6 +23,7 @@ internal struct RUMScopeDependencies {
     let applicationVersion: String
     let sdkVersion: String
     let source: String
+    let firstPartyURLsFilter: FirstPartyURLsFilter
     let eventBuilder: RUMEventBuilder
     let eventOutput: RUMEventOutput
     let rumUUIDGenerator: RUMUUIDGenerator
@@ -61,6 +62,7 @@ internal extension RUMScopeDependencies {
             applicationVersion: rumFeature.configuration.common.applicationVersion,
             sdkVersion: rumFeature.configuration.common.sdkVersion,
             source: rumFeature.configuration.common.source,
+            firstPartyURLsFilter: FirstPartyURLsFilter(hosts: rumFeature.configuration.firstPartyHosts),
             eventBuilder: RUMEventBuilder(
                 eventsMapper: rumFeature.eventsMapper
             ),

diff --git a/Sources/Datadog/RUMMonitor.swift b/Sources/Datadog/RUMMonitor.swift
@@ -349,7 +349,7 @@ public class RUMMonitor: DDRUMMonitor, RUMCommandSubscriber {
                 url: request.url?.absoluteString ?? "unknown_url",
                 httpMethod: RUMMethod(httpMethod: request.httpMethod),
                 kind: RUMResourceType(request: request),
-                isFirstPartyRequest: nil,
+                isFirstPartyRequest: applicationScope.dependencies.firstPartyURLsFilter.isFirstParty(url: request.url),
                 spanContext: nil
             )
         )
@@ -368,7 +368,7 @@ public class RUMMonitor: DDRUMMonitor, RUMCommandSubscriber {
                 url: url.absoluteString,
                 httpMethod: .get,
                 kind: nil,
-                isFirstPartyRequest: nil,
+                isFirstPartyRequest: applicationScope.dependencies.firstPartyURLsFilter.isFirstParty(url: url),
                 spanContext: nil
             )
         )
@@ -388,7 +388,7 @@ public class RUMMonitor: DDRUMMonitor, RUMCommandSubscriber {
                 url: urlString,
                 httpMethod: httpMethod,
                 kind: nil,
-                isFirstPartyRequest: nil,
+                isFirstPartyRequest: applicationScope.dependencies.firstPartyURLsFilter.isFirstParty(string: urlString),
                 spanContext: nil
             )
         )

diff --git a/...atadog/URLSessionAutoInstrumentation/Interception/URLFiltering/FirstPartyURLsFilter.swift b/...atadog/URLSessionAutoInstrumentation/Interception/URLFiltering/FirstPartyURLsFilter.swift
@@ -32,4 +32,15 @@ internal struct FirstPartyURLsFilter {
         }
         return host.range(of: regex, options: .regularExpression) != nil
     }
+
+    // Returns `true` if given `String` can be parsed as a URL and matches the first
+    // party hosts defined by the user; `false` otherwise
+    func isFirstParty(string: String) -> Bool {
+        guard let url = URL(string: string),
+              let regex = self.regex,
+              let host = url.host else {
+            return false
+        }
+        return host.range(of: regex, options: .regularExpression) != nil
+    }
 }
diff --git a/Tests/DatadogTests/Datadog/Mocks/CoreMocks.swift b/Tests/DatadogTests/Datadog/Mocks/CoreMocks.swift
@@ -268,7 +268,8 @@ extension FeaturesConfiguration.RUM {
         longTaskEventMapper: RUMLongTaskEventMapper? = nil,
         instrumentation: FeaturesConfiguration.RUM.Instrumentation? = nil,
         backgroundEventTrackingEnabled: Bool = false,
-        onSessionStart: @escaping RUMSessionListener = mockNoOpSessionListener()
+        onSessionStart: @escaping RUMSessionListener = mockNoOpSessionListener(),
+        firstPartyHosts: Set<String> = []
     ) -> Self {
         return .init(
             common: common,
@@ -285,7 +286,8 @@ extension FeaturesConfiguration.RUM {
             longTaskEventMapper: longTaskEventMapper,
             instrumentation: instrumentation,
             backgroundEventTrackingEnabled: backgroundEventTrackingEnabled,
-            onSessionStart: onSessionStart
+            onSessionStart: onSessionStart,
+            firstPartyHosts: firstPartyHosts
         )
     }
 }

diff --git a/Tests/DatadogTests/Datadog/Mocks/RUMFeatureMocks.swift b/Tests/DatadogTests/Datadog/Mocks/RUMFeatureMocks.swift
@@ -686,6 +686,7 @@ extension RUMScopeDependencies {
             applicationVersion: applicationVersion,
             sdkVersion: sdkVersion,
             source: source,
+            firstPartyURLsFilter: FirstPartyURLsFilter(hosts: []),
             eventBuilder: eventBuilder,
             eventOutput: eventOutput,
             rumUUIDGenerator: rumUUIDGenerator,
@@ -714,6 +715,7 @@ extension RUMScopeDependencies {
         applicationVersion: String? = nil,
         sdkVersion: String? = nil,
         source: String? = nil,
+        firstPartyUrls: Set<String>? = nil,
         eventBuilder: RUMEventBuilder? = nil,
         eventOutput: RUMEventOutput? = nil,
         rumUUIDGenerator: RUMUUIDGenerator? = nil,
@@ -736,6 +738,7 @@ extension RUMScopeDependencies {
             applicationVersion: applicationVersion ?? self.applicationVersion,
             sdkVersion: sdkVersion ?? self.sdkVersion,
             source: source ?? self.source,
+            firstPartyURLsFilter: firstPartyUrls != nil ? FirstPartyURLsFilter(hosts: firstPartyUrls!) : self.firstPartyURLsFilter,
             eventBuilder: eventBuilder ?? self.eventBuilder,
             eventOutput: eventOutput ?? self.eventOutput,
             rumUUIDGenerator: rumUUIDGenerator ?? self.rumUUIDGenerator,

diff --git a/Tests/DatadogTests/Datadog/RUMMonitorTests.swift b/Tests/DatadogTests/Datadog/RUMMonitorTests.swift
@@ -262,6 +262,7 @@ class RUMMonitorTests: XCTestCase {
         let resourceEvent = session.viewVisits[0].resourceEvents[0]
         XCTAssertEqual(resourceEvent.resource.url, url.absoluteString)
         XCTAssertEqual(resourceEvent.resource.statusCode, 200)
+        XCTAssertNil(resourceEvent.resource.provider?.type)
     }
 
     func testStartingView_thenLoadingResourceWithURLString() throws {
@@ -284,6 +285,57 @@ class RUMMonitorTests: XCTestCase {
         XCTAssertEqual(resourceEvent.resource.statusCode, 333)
         XCTAssertEqual(resourceEvent.resource.type, .beacon)
         XCTAssertEqual(resourceEvent.resource.method, .post)
+        XCTAssertNil(resourceEvent.resource.provider?.type)
+    }
+
+    func testLoadingResourceWithURL_thenMarksFirstPartyURLs() throws {
+        RUMFeature.instance = .mockByRecordingRUMEventMatchers(
+            directories: temporaryFeatureDirectories,
+            configuration: .mockWith(
+                // .mockRandom always uses foo.com
+                firstPartyHosts: ["foo.com"]
+            )
+        )
+        defer { RUMFeature.instance?.deinitialize() }
+
+        let monitor = try createTestableRUMMonitor()
+        setGlobalAttributes(of: monitor)
+
+        let url: URL = .mockRandom()
+        monitor.startView(viewController: mockView)
+        monitor.startResourceLoading(resourceKey: "/resource/1", url: url)
+        monitor.stopResourceLoading(resourceKey: "/resource/1", response: .mockWith(statusCode: 200, mimeType: "image/png"))
+
+        let rumEventMatchers = try RUMFeature.waitAndReturnRUMEventMatchers(count: 4)
+        verifyGlobalAttributes(in: rumEventMatchers)
+
+        let session = try XCTUnwrap(try RUMSessionMatcher.groupMatchersBySessions(rumEventMatchers).first)
+        let resourceEvent = session.viewVisits[0].resourceEvents[0]
+        XCTAssertEqual(resourceEvent.resource.provider?.type, RUMResourceEvent.Resource.Provider.ProviderType.firstParty)
+    }
+
+    func testLoadingResourceWithURLString_thenMarksFirstPartyURLs() throws {
+        RUMFeature.instance = .mockByRecordingRUMEventMatchers(
+            directories: temporaryFeatureDirectories,
+            configuration: .mockWith(
+                firstPartyHosts: ["foo.com"]
+            )
+        )
+        defer { RUMFeature.instance?.deinitialize() }
+
+        let monitor = try createTestableRUMMonitor()
+        setGlobalAttributes(of: monitor)
+
+        monitor.startView(viewController: mockView)
+        monitor.startResourceLoading(resourceKey: "/resource/1", httpMethod: .post, urlString: "http://www.foo.com/some/url/string", attributes: [:])
+        monitor.stopResourceLoading(resourceKey: "/resource/1", statusCode: 333, kind: .beacon)
+
+        let rumEventMatchers = try RUMFeature.waitAndReturnRUMEventMatchers(count: 4)
+        verifyGlobalAttributes(in: rumEventMatchers)
+
+        let session = try XCTUnwrap(try RUMSessionMatcher.groupMatchersBySessions(rumEventMatchers).first)
+        let resourceEvent = session.viewVisits[0].resourceEvents[0]
+        XCTAssertEqual(resourceEvent.resource.provider?.type, RUMResourceEvent.Resource.Provider.ProviderType.firstParty)
     }
 
     func testStartingView_thenTappingButton() throws {