DEMRUM-773: Network Monitor Module

Package.swift

@@ -57,6 +57,7 @@ func generateMainTargets() -> [Target] {
                 "SplunkCrashReports",
                 "SplunkSessionReplayProxy",
                 "SplunkNetwork",
+                "SplunkNetworkInfo",
                 "SplunkSlowFrameDetector",
                 "SplunkOpenTelemetry",
                 "SplunkAppStart",
@@ -100,10 +101,25 @@ func generateMainTargets() -> [Target] {
             dependencies: ["SplunkNetwork"],
             path: "SplunkNetwork/Tests"
         ),
-
-
-        // MARK: - Splunk Common
-
+
+        // MARK: Splunk Network Info
+
+        .target(
+            name: "SplunkNetworkInfo",
+            dependencies: [
+                "SplunkCommon",
+                "SplunkOpenTelemetry"
+            ],
+            path: "SplunkNetworkInfo/Sources"
+        ),
+        .testTarget(
+            name: "SplunkNetworkInfoTests",
+            dependencies: ["SplunkNetworkInfo"],
+            path: "SplunkNetworkInfo/Tests"
+        ),
+
+        // MARK: Splunk Common
+
         .target(
             name: "SplunkCommon",
             path: "SplunkCommon/Sources"

SplunkAgent/Sources/SplunkAgent/Agent/Modules/Pool/DefaultModulesPool.swift

@@ -25,6 +25,10 @@ internal import SplunkCommon
     internal import SplunkNetwork
 #endif
 
+#if canImport(SplunkNetworkInfo)
+    internal import SplunkNetworkInfo
+#endif
+
 #if canImport(CiscoSessionReplay)
     internal import CiscoSessionReplay
     internal import SplunkSessionReplayProxy
@@ -70,6 +74,11 @@ class DefaultModulesPool: AgentModulesPool {
             knownModules.append(NetworkInstrumentation.self)
         #endif
 
+        // Network Info
+        #if canImport(SplunkNetworkInfo)
+            knownModules.append(NetworkInfo.self)
+        #endif
+
         // Slow Frame Detector
         #if canImport(SplunkSlowFrameDetector)
             knownModules.append(SlowFrameDetector.self)

SplunkAgent/Sources/SplunkAgent/Agent/Modules/SplunkRum+Modules.swift

@@ -19,6 +19,7 @@ import Foundation
 internal import CiscoSessionReplay
 internal import SplunkAppStart
 internal import SplunkNetwork
+internal import SplunkNetworkInfo
 
 #if canImport(SplunkCrashReports)
     internal import SplunkCrashReports
@@ -53,6 +54,7 @@ extension SplunkRum {
         customizeSessionReplay()
         customizeNetwork()
         customizeAppStart()
+        customizeNetworkInfo()
         customizeWebViewInstrumentation()
     }
 
@@ -113,6 +115,13 @@ extension SplunkRum {
         appStartModule?.sharedState = sharedState
     }
 
+    /// Configure NetworkInfo module
+    private func customizeNetworkInfo() {
+        let networkInfoModule = modulesManager?.module(ofType: SplunkNetworkInfo.NetworkInfo.self)
+
+        networkInfoModule?.sharedState = sharedState
+    }
+
     /// Configure WebView intrumentation module
     private func customizeWebViewInstrumentation() {
         // Get WebViewInstrumentation module, set its sharedState

SplunkNetworkInfo/Sources/SplunkNetworkInfo/Module/NetworkInfo+Module.swift

@@ -0,0 +1,51 @@
+//
+/*
+Copyright 2025 Splunk Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import Foundation
+import SplunkCommon
+
+
+public struct NetworkInfoData: ModuleEventData {}
+
+public struct NetworkInfoMetadata: ModuleEventMetadata {
+    public var timestamp = Date()
+    public var eventName: String = "network.change"
+}
+
+extension NetworkInfo: Module {
+
+    // MARK: - Module types
+
+    public typealias Configuration = NetworkInfoConfiguration
+    public typealias RemoteConfiguration = NetworkInfoRemoteConfiguration
+
+    public typealias EventMetadata = NetworkInfoMetadata
+    public typealias EventData = NetworkInfoData
+
+
+    // MARK: - Module methods
+
+    public func install(with configuration: (any ModuleConfiguration)?, remoteConfiguration: (any RemoteModuleConfiguration)?) {
+        startDetection()
+    }
+
+
+    // MARK: - Type transparency helpers
+
+    public func deleteData(for metadata: any ModuleEventMetadata) {}
+    public func onPublish(data: @escaping (NetworkInfoMetadata, NetworkInfoData) -> Void) {}
+}

SplunkNetworkInfo/Sources/SplunkNetworkInfo/Module/NetworkInfoConfiguration.swift

@@ -0,0 +1,22 @@
+//
+/*
+Copyright 2025 Splunk Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import Foundation
+import SplunkCommon
+
+/// NetworkInfo module configuration, minimal configuration for module conformance.
+public struct NetworkInfoConfiguration: ModuleConfiguration {}

SplunkNetworkInfo/Sources/SplunkNetworkInfo/Module/NetworkInfoRemoteConfiguration.swift

@@ -0,0 +1,54 @@
+//
+/*
+Copyright 2025 Splunk Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import Foundation
+import SplunkCommon
+
+/// NetworkInfo remote configuration.
+public struct NetworkInfoRemoteConfiguration: RemoteModuleConfiguration {
+
+    // MARK: - Internal decoding
+
+    struct NetworkInfo: Decodable {
+        let enabled: Bool
+    }
+
+    struct MRUMRoot: Decodable {
+        let networkInfo: NetworkInfo
+    }
+
+    struct Configuration: Decodable {
+        let mrum: MRUMRoot
+    }
+
+    struct Root: Decodable {
+        let configuration: Configuration
+    }
+
+
+    // MARK: - Public
+
+    public var enabled: Bool
+
+    public init?(from data: Data) {
+        guard let root = try? JSONDecoder().decode(Root.self, from: data) else {
+            return nil
+        }
+
+        enabled = root.configuration.mrum.networkInfo.enabled
+    }
+}

SplunkNetworkInfo/Sources/SplunkNetworkInfo/NetworkInfo.swift

@@ -0,0 +1,103 @@
+//
+/*
+Copyright 2025 Splunk Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import Foundation
+import Network
+import SplunkCommon
+import OpenTelemetryApi
+
+public class NetworkInfo {
+    public enum ConnectionType: String {
+        case wifi
+        case cellular
+        case wiredEthernet
+        case other
+        case lost
+    }
+
+    /// An instance of the Agent shared state object, which is used to obtain agent's state, e.g. a session id.
+    public unowned var sharedState: AgentSharedState?
+
+    public static let shared = NetworkInfo()
+
+    private let monitor = NWPathMonitor()
+    private let queue = DispatchQueue(label: "NetworkMonitorQueue")
+
+    public private(set) var isConnected: Bool = false
+    public private(set) var connectionType: ConnectionType = .lost
+    public private(set) var isVPNActive: Bool = false
+
+    public var statusChangeHandler: ((Bool, ConnectionType, Bool) -> Void)?
+
+    // MARK: - Initialization
+
+    // Module conformance
+    public required init() { }
+
+    public func startDetection() {
+        monitor.pathUpdateHandler = { [weak self] path in
+            guard let self = self else { return }
+            self.isConnected = path.status == .satisfied
+            self.connectionType = self.getConnectionType(path)
+            self.isVPNActive = path.availableInterfaces.contains(where: { iface in
+                iface.type == .other &&
+                (iface.name.lowercased().contains("utun") ||
+                 iface.name.lowercased().contains("ppp") ||
+                 iface.name.lowercased().contains("ipsec"))
+            })
+            self.sendNetworkChangeSpan()
+            self.statusChangeHandler?(self.isConnected, self.connectionType, self.isVPNActive)
+        }
+        monitor.start(queue: queue)
+        // Send initial state span
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { [weak self] in
+            self?.sendNetworkChangeSpan()
+        }
+    }
+
+    private func getConnectionType(_ path: NWPath) -> ConnectionType {
+        if path.usesInterfaceType(.wifi) {
+            return .wifi
+        } else if path.usesInterfaceType(.cellular) {
+            return .cellular
+        } else if path.usesInterfaceType(.wiredEthernet) {
+            return .wiredEthernet
+        } else if path.status == .unsatisfied {
+            return .lost
+        } else {
+            return .other
+        }
+    }
+
+    private func sendNetworkChangeSpan() {
+
+        let tracer = OpenTelemetry.instance
+            .tracerProvider
+            .get(
+                instrumentationName: "NetworkInfo",
+                instrumentationVersion: sharedState?.agentVersion
+            )
+
+        let span = tracer.spanBuilder(spanName: "network.change")
+                .setStartTime(time: Date())
+                .startSpan()
+        span.setAttribute(key: "network.connected", value: isConnected)
+        span.setAttribute(key: "network.connection.type", value: connectionType.rawValue)
+        span.setAttribute(key: "network.vpn", value: isVPNActive)
+        span.end(time: Date())
+    }
+}