Reporting updates (#49)

* Only mark upload as started if its ready

* Reporting updates

Add upload failed and input standardization events

Add standardization failure event handler to reporter

Add standardization success event handler to reporter

Rename method for upload success

Rename upload event to upload succeeded

Support dispatching multiple events at the same time

Naive non-thread safe implementation reporter networking

Change event type casing, individual files for events

Fix reporter test

Actually report upload failure

Read off file size

Use Date in events and serialize to ISO8601 string

Finangle duration and start time

Set correct version in correct place

Keep a session UUID

Route every request through one chokepoint

Upload failed test

Shared test encoder

Input standardization failed test

Input standardization succeeded test

Better organize expected json strings

Use a shared instance

Remove dupe file

* Thread asset duration through inspection and standardization

* Pass export error back

* Include non standard input reasons

* Workaround duration load pause

* Add early return in delegate callback

* Call correct method

* Overloaded methods

* Avoid mutating while iterating

* tests

* Remove unnecessary check

Author: andrewjl-mux

Sources/MuxUploadSDK/Extensions/NSMutableURLRequest.swift renamed to Sources/MuxUploadSDK/Extensions/NSMutableURLRequest+Reporting.swift

@@ -21,9 +21,12 @@ enum UploadInputFormatInspectionResult {
         case unsupportedPixelFormat
     }
 
-    case inspectionFailure
-    case standard
-    case nonstandard([NonstandardInputReason])
+    case inspectionFailure(duration: CMTime)
+    case standard(duration: CMTime)
+    case nonstandard(
+        reasons: [NonstandardInputReason],
+        duration: CMTime
+    )
 
     var isStandard: Bool {
         if case Self.standard = self {
@@ -33,12 +36,52 @@ enum UploadInputFormatInspectionResult {
         }
     }
 
+    var sourceInputDuration: CMTime {
+        switch self {
+        case .inspectionFailure(duration: let duration):
+            return duration
+        case .standard(duration: let duration):
+            return duration
+        case .nonstandard(_, duration: let duration):
+            return duration
+        }
+    }
+
     var nonstandardInputReasons: [NonstandardInputReason]? {
-        if case Self.nonstandard(let nonstandardInputReasons) = self {
+        if case Self.nonstandard(let nonstandardInputReasons, _) = self {
             return nonstandardInputReasons
         } else {
             return nil
         }
     }
 
 }
+
+extension UploadInputFormatInspectionResult.NonstandardInputReason: CustomStringConvertible {
+    var description: String {
+        switch self {
+        case .audioCodec:
+            return "audio_codec"
+        case .audioEditList:
+            return "audio_edit_list"
+        case .pixelAspectRatio:
+            return "pixel_aspect_ratio"
+        case .videoBitrate:
+            return "video_bitrate"
+        case .videoCodec:
+            return "video_codec"
+        case .videoEditList:
+            return "video_edit_list"
+        case .videoFrameRate:
+            return "video_frame_rate"
+        case .videoGOPSize:
+            return "video_gop_size"
+        case .videoResolution:
+            return "video_resolution"
+        case .unexpectedMediaFileParameters:
+            return "unexpected_media_file_parameters"
+        case .unsupportedPixelFormat:
+            return "unsupported_pixel_format"
+        }
+    }
+}

Sources/MuxUploadSDK/InputInspection/UploadInputFormatInspectionResult.swift

@@ -20,50 +20,83 @@ class AVFoundationUploadInputInspector: UploadInputInspector {
     func performInspection(
         sourceInput: AVAsset,
         completionHandler: @escaping (UploadInputFormatInspectionResult) -> ()
+    ) {
+        sourceInput.loadValuesAsynchronously(
+            forKeys: [
+                "duration"
+            ]
+        ) {
+            // FIXME: Trying to avoid the callback pyramid of doom
+            // here, newer AVAsset APIs use Concurrency
+            // but Concurrency itself has very primitive
+            // task sequencing. Replace with async AVAsset
+            // methods.
+            let sourceInputDuration = sourceInput.duration
+            self.performInspection(
+                sourceInput: sourceInput,
+                sourceInputDuration: sourceInputDuration,
+                completionHandler: completionHandler
+            )
+        }
+    }
+
+    func performInspection(
+        sourceInput: AVAsset,
+        sourceInputDuration: CMTime,
+        completionHandler: @escaping (UploadInputFormatInspectionResult) -> ()
     ) {
         // TODO: Eventually load audio tracks too
         if #available(iOS 15, *) {
             sourceInput.loadTracks(
                 withMediaType: .video
             ) { tracks, error in
                 if error != nil {
-                    completionHandler(.inspectionFailure)
+                    completionHandler(
+                        .inspectionFailure(duration: sourceInputDuration)
+                    )
                     return
                 }
 
                 if let tracks {
                     self.inspect(
+                        sourceInputDuration: sourceInputDuration,
                         tracks: tracks,
                         completionHandler: completionHandler
                     )
                 }
             }
         } else {
             sourceInput.loadValuesAsynchronously(
-                forKeys: ["tracks"]
+                forKeys: [
+                    "tracks"
+                ]
             ) {
                 // Non-blocking if "tracks" is already loaded
                 let tracks = sourceInput.tracks(
                     withMediaType: .video
                 )
+
                 self.inspect(
+                    sourceInputDuration: sourceInputDuration,
                     tracks: tracks,
                     completionHandler: completionHandler
                 )
             }
         }
-
     }
 
     func inspect(
+        sourceInputDuration: CMTime,
         tracks: [AVAssetTrack],
         completionHandler: @escaping (UploadInputFormatInspectionResult) -> ()
     ) {
         switch tracks.count {
         case 0:
             // Nothing to inspect, therefore nothing to standardize
             // declare as already standard
-            completionHandler(.standard)
+            completionHandler(
+                .standard(duration: sourceInputDuration)
+            )
         case 1:
             if let track = tracks.first {
                 track.loadValuesAsynchronously(
@@ -73,12 +106,18 @@ class AVFoundationUploadInputInspector: UploadInputInspector {
                     ]
                 ) {
                     guard let formatDescriptions = track.formatDescriptions as? [CMFormatDescription] else {
-                        completionHandler(.inspectionFailure)
+                        completionHandler(
+                            .inspectionFailure(
+                                duration: sourceInputDuration
+                            )
+                        )
                         return
                     }
 
                     guard let formatDescription = formatDescriptions.first else {
-                        completionHandler(.inspectionFailure)
+                        completionHandler(
+                            .inspectionFailure(duration: sourceInputDuration)
+                        )
                         return
                     }
 
@@ -106,17 +145,21 @@ class AVFoundationUploadInputInspector: UploadInputInspector {
                     }
 
                     if nonStandardReasons.isEmpty {
-                        completionHandler(.standard)
+                        completionHandler(
+                            .standard(duration: sourceInputDuration)
+                        )
                     } else {
-                        completionHandler(.nonstandard(nonStandardReasons))
+                        completionHandler(.nonstandard(reasons: nonStandardReasons, duration: sourceInputDuration))
                     }
 
                 }
             }
         default:
             // Inspection fails for multi-video track inputs
             // for the time being
-            completionHandler(.inspectionFailure)
+            completionHandler(
+                .inspectionFailure(duration: sourceInputDuration)
+            )
         }
     }
 }

Sources/MuxUploadSDK/InputInspection/UploadInputInspector.swift

@@ -19,6 +19,22 @@ enum StandardizationStrategy {
     case exportSession
 }
 
+struct StandardizationError: Error {
+    var localizedDescription: String
+
+    static var missingExportPreset = StandardizationError(
+        localizedDescription: "Missing export session preset"
+    )
+
+    static var exportSessionInitializationFailure = StandardizationError(
+        localizedDescription: "Export session failed to initialize"
+    )
+
+    static var standardizedAssetExportFailure = StandardizationError(
+        localizedDescription: "Failed to export standardized asset"
+    )
+}
+
 class UploadInputStandardizationWorker {
 
     var sourceInput: AVAsset?
@@ -29,7 +45,7 @@ class UploadInputStandardizationWorker {
         sourceAsset: AVAsset,
         maximumResolution: UploadOptions.InputStandardization.MaximumResolution,
         outputURL: URL,
-        completion: @escaping (AVAsset, AVAsset?, URL?, Bool) -> ()
+        completion: @escaping (AVAsset, AVAsset?, Error?) -> ()
     ) {
 
         let availableExportPresets = AVAssetExportSession.allExportPresets()
@@ -45,7 +61,7 @@ class UploadInputStandardizationWorker {
             $0 == exportPreset
         }) else {
             // TODO: Use VideoToolbox if export preset unavailable
-            completion(sourceAsset, nil, nil, false)
+            completion(sourceAsset, nil, StandardizationError.missingExportPreset)
             return
         }
 
@@ -54,7 +70,7 @@ class UploadInputStandardizationWorker {
             presetName: exportPreset
         ) else {
             // TODO: Use VideoToolbox if export session fails to initialize
-            completion(sourceAsset, nil, nil, false)
+            completion(sourceAsset, nil, StandardizationError.exportSessionInitializationFailure)
             return
         }
 
@@ -64,12 +80,12 @@ class UploadInputStandardizationWorker {
         // TODO: Use Swift Concurrency
         exportSession.exportAsynchronously {
             if let exportError = exportSession.error {
-                completion(sourceAsset, nil, nil, false)
+                completion(sourceAsset, nil, exportError)
             } else if let standardizedAssetURL = exportSession.outputURL {
                 let standardizedAsset = AVAsset(url: standardizedAssetURL)
-                completion(sourceAsset, standardizedAsset, outputURL, true)
+                completion(sourceAsset, standardizedAsset, nil)
             } else {
-                completion(sourceAsset, nil, nil, false)
+                completion(sourceAsset, nil, StandardizationError.standardizedAssetExportFailure)
             }
         }
     }

Sources/MuxUploadSDK/InputStandardization/UploadInputStandardizationWorker.swift

@@ -13,7 +13,7 @@ class UploadInputStandardizer {
         sourceAsset: AVAsset,
         maximumResolution: UploadOptions.InputStandardization.MaximumResolution,
         outputURL: URL,
-        completion: @escaping (AVAsset, AVAsset?, URL?, Bool) -> ()
+        completion: @escaping (AVAsset, AVAsset?, Error?) -> ()
     ) {
         let worker = UploadInputStandardizationWorker()
 

Sources/MuxUploadSDK/InputStandardization/UploadInputStandardizer.swift

@@ -96,7 +96,7 @@ class ChunkedFile {
         let fileSize = try fileManager.fileSizeOfItem(
             atPath: fileURL.path
         )
-
+        
         guard let data = data else {
             // Called while already at the end of the file. We read zero bytes, "ending" at the end of the file
             return FileChunk(startByte: fileSize, endByte: fileSize, totalFileSize: fileSize, chunkData: Data(capacity: 0))

Sources/MuxUploadSDK/InternalUtilities/ChunkedFile.swift

@@ -0,0 +1,31 @@
+//
+//  InputStandardizationFailedEvent.swift
+//  
+
+import Foundation
+
+struct InputStandardizationFailedEvent: Codable {
+    var type: String = "upload_input_standardization_failed"
+    var sessionID: String
+    var version: String = "1"
+    var data: Data
+
+    struct Data: Codable {
+        var appName: String?
+        var appVersion: String?
+        var deviceModel: String
+        var errorDescription: String
+        var inputDuration: Double
+        var inputSize: UInt64
+        var maximumResolution: String
+        var nonStandardInputReasons: [String]
+        var platformName: String
+        var platformVersion: String
+        var regionCode: String?
+        var sdkVersion: String
+        var standardizationStartTime: Date
+        var standardizationEndTime: Date
+        var uploadCanceled: Bool
+        var uploadURL: URL
+    }
+}

Sources/MuxUploadSDK/InternalUtilities/Reporting/InputStandardizationFailedEvent.swift

@@ -0,0 +1,29 @@
+//
+//  InputStandardizationSucceededEvent.swift
+//  
+
+import Foundation
+
+struct InputStandardizationSucceededEvent: Codable {
+    var type: String = "upload_input_standardization_succeeded"
+    var sessionID: String
+    var version: String = "1"
+    var data: Data
+
+    struct Data: Codable {
+        var appName: String?
+        var appVersion: String?
+        var deviceModel: String
+        var inputDuration: Double
+        var inputSize: UInt64
+        var maximumResolution: String
+        var nonStandardInputReasons: [String]
+        var platformName: String
+        var platformVersion: String
+        var regionCode: String?
+        var sdkVersion: String
+        var standardizationStartTime: Date
+        var standardizationEndTime: Date
+        var uploadURL: URL
+    }
+}