Change to runtime framework linking

Author: Wouter01

Package.swift

@@ -25,10 +25,12 @@ let package = Package(
 
         .target(
             name: "ExternalAppLoggerHeaders",
-            path: "Sources/Headers",
-            linkerSettings: [
-                .linkedFramework("LoggingSupport")
-            ]
+            path: "Sources/Headers"
+        ),
+
+        .testTarget(
+            name: "LogStreamTests",
+            dependencies: ["LogStream"]
         )
     ]
 )

README.md

@@ -4,6 +4,9 @@ This package provides some utilities to capture logs of other processes. This ca
 
 The logs captured are the same ones visible in Console.app.
 
+> [!IMPORTANT]
+> This package makes use of the private framework LoggingSupport. While unlikely, OS updates might change the internals of the framework and break this package.
+
 ## Usage
 
 Capturing logs for one process:
@@ -29,5 +32,3 @@ To capture logs of all processes, use the following initializer:
 ```swift
 public static func logs(flags: ActivityStreamOptions) -> AsyncStream<LogMessage>
 ```
-
-> Note: To link against the private framework LoggingSupport, which is used by this package, you may be required to set an extra search path. You can do this by adding the following to `System Framework Search Paths` in your projects build settings: `$(DEVELOPER_SDK_DIR)/MacOSX.sdk/System/Library/PrivateFrameworks`

Sources/Headers/include/OSActivityEvent.h

@@ -26,4 +26,6 @@ public extension ActivityStreamOptions {
     static let info = ActivityStreamOptions(rawValue: 1 << 8)
     static let promiscuous = ActivityStreamOptions(rawValue: 1 << 9)
     static let preciseTimestamps = ActivityStreamOptions(rawValue: 1 << 9)
+
+    static let `default`: ActivityStreamOptions = [.historical, .processOnly]
 }

Sources/LogStream/ActivityStreamOptions.swift

@@ -45,7 +45,7 @@ extension LogMessage: Hashable {
 }
 
 extension LogMessage {
-    init(_ event: OSActivityLogMessageEvent) {
+    init(_ event: _OSActivityLogMessageEvent) {
         self.init(
             message: event.eventMessage,
             date: event.timestamp,
@@ -57,3 +57,16 @@ extension LogMessage {
         )
     }
 }
+
+@objc
+protocol _OSActivityLogMessageEvent {
+    var eventMessage: String { get set }
+    var timestamp: Date { get set }
+    var subsystem: String? { get set }
+    var category: String? { get set }
+    var messageType: UInt8 { get set }
+    var process: String { get set }
+    var processID: pid_t { get set }
+
+    init(entry: UnsafeMutablePointer<os_activity_stream_entry_s>)
+}

Sources/LogStream/LogMessage.swift

@@ -6,6 +6,7 @@
 //
 
 import ExternalAppLoggerHeaders
+import Foundation
 
 public enum LogStream {
 
@@ -28,17 +29,17 @@ public enum LogStream {
     ///     }
     /// }
     /// ```
-    public static func logs(for processID: pid_t, flags: ActivityStreamOptions = [.historical, .processOnly]) -> AsyncStream<LogMessage> {
+    public static func logs(for processID: pid_t, flags: ActivityStreamOptions = .default) -> AsyncStream<LogMessage> {
 
         let (stream, continuation) = AsyncStream.makeStream(of: LogMessage.self)
 
         let logstream = createStream(pid: processID, flags: flags, continuation: continuation)
 
         continuation.onTermination = { _ in
-            cancelLog(stream: logstream)
+            LoggingSupport.cancelLog(logstream)
         }
 
-        resumeLog(stream: logstream)
+        LoggingSupport.resumeLog(logstream)
 
         return stream
     }
@@ -60,18 +61,18 @@ public enum LogStream {
     ///     }
     /// }
     /// ```
-    public static func logs(for processIDs: [pid_t], flags: ActivityStreamOptions = [.historical, .processOnly]) -> AsyncStream<LogMessage> {
+    public static func logs(for processIDs: [pid_t], flags: ActivityStreamOptions = .default) -> AsyncStream<LogMessage> {
         let (stream, continuation) = AsyncStream.makeStream(of: LogMessage.self)
 
         let logstreams = processIDs.map {
             createStream(pid: $0, flags: flags, continuation: continuation)
         }
 
         continuation.onTermination = { _ in
-            logstreams.forEach(cancelLog)
+            logstreams.forEach(LoggingSupport.cancelLog)
         }
 
-        logstreams.forEach(resumeLog)
+        logstreams.forEach(LoggingSupport.resumeLog)
 
         return stream
     }
@@ -91,43 +92,30 @@ public enum LogStream {
     ///     }
     /// }
     /// ```
-    public static func logs(flags: ActivityStreamOptions = [.historical, .processOnly]) -> AsyncStream<LogMessage> {
+    public static func logs(flags: ActivityStreamOptions = .default) -> AsyncStream<LogMessage> {
         LogStream.logs(for: -1, flags: flags)
     }
 
+    static let messageClass = unsafeBitCast(NSClassFromString("OSActivityLogMessageEvent"), to: _OSActivityLogMessageEvent.Type.self)
+
     static func createStream(
         pid: pid_t,
         flags: ActivityStreamOptions,
         continuation: AsyncStream<LogMessage>.Continuation
-    ) -> ActivityStream? {
-        streamLog(pid: pid, flags: flags.rawValue) { entryPointer, error in
+    ) -> LoggingSupport.ActivityStream? {
+        LoggingSupport.streamLog(pid, flags.rawValue) { entryPointer, error in
             guard error == 0, let entryPointer else { return false }
 
             let entry = entryPointer.pointee
 
-            guard 
+            guard
                 entry.type == OS_ACTIVITY_STREAM_TYPE_LOG_MESSAGE || entry.type == OS_ACTIVITY_STREAM_TYPE_LEGACY_LOG_MESSAGE
             else { return true }
 
-            let event = OSActivityLogMessageEvent(entry: entryPointer)
+            let event = messageClass.init(entry: entryPointer)
 
             continuation.yield(LogMessage(event))
             return true
         }
     }
 }
-
-typealias ActivityStream = os_activity_stream_t
-
-@_silgen_name("os_activity_stream_for_pid")
-fileprivate func streamLog(
-    pid: pid_t,
-    flags: ActivityStreamOptions.RawValue,
-    stream_block: (@convention(block) (os_activity_stream_entry_t?, Int32) -> Bool)?
-) -> ActivityStream?
-
-@_silgen_name("os_activity_stream_resume")
-fileprivate func resumeLog(stream: ActivityStream?)
-
-@_silgen_name("os_activity_stream_cancel")
-fileprivate func cancelLog(stream: ActivityStream?)

Sources/LogStream/LogStream.swift

@@ -0,0 +1,29 @@
+//
+//  LoggingSupport.swift
+//  
+//
+//  Created by Wouter on 26/4/24.
+//
+
+import Foundation
+import ExternalAppLoggerHeaders
+
+enum LoggingSupport {
+    nonisolated(unsafe) static let handle = dlopen("/System/Library/PrivateFrameworks/LoggingSupport.framework/LoggingSupport", RTLD_LAZY),
+                            streamLog = unsafeBitCast(dlsym(handle, "os_activity_stream_for_pid"), to: StreamLog.self),
+                            resumeLog = unsafeBitCast(dlsym(handle, "os_activity_stream_resume"), to: ResumeLog.self),
+                            cancelLog = unsafeBitCast(dlsym(handle, "os_activity_stream_cancel"), to: CancelLog.self)
+
+    typealias StreamLog = @convention(c) (
+        pid_t,
+        ActivityStreamOptions.RawValue,
+        (@convention(block) (os_activity_stream_entry_t?, Int32) -> Bool)?
+    ) -> ActivityStream?
+
+    typealias ResumeLog = @convention(c) (ActivityStream?) -> Void
+
+    typealias CancelLog = ResumeLog
+
+    typealias ActivityStream = OpaquePointer
+
+}