Move reporting to own directory

Add event defintions

Rename method for upload success

Add standardization success method

Device and locale become properties

Reporting method for standardization failure

Add Hashable conformance

Support dispatching multiple events at the same time

Naive non-thread safe implementation

Revert "Add Hashable conformance"

This reverts commit a4c8b53.

Rename upload event to upload succeeded

Add upload failed event

Adjust upload succeeded event

Include missing parameters upload failed event

Change event type casing, individual files for events

Fix reporter test

reporting property

Actually report upload failure

Remove file

Read off file size

Use date in events

Finangle duration and start time

Consistent spelling of reporter methods

Centralize checking for optOut in only one place

Set correct version in correct place

session UUID

request extension own file

extension

Use Date for input standardization span

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

format

Author: andrewjl-mux

Sources/MuxUploadSDK/Extensions/NSMutableURLRequest.swift renamed to Sources/MuxUploadSDK/Extensions/NSMutableURLRequest+Reporting.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
+    }
+}

Sources/MuxUploadSDK/InternalUtilities/Reporting/InputStandardizationSucceededEvent.swift

@@ -9,11 +9,18 @@ import Foundation
 import UIKit
 
 class Reporter: NSObject {
+
+    static let shared: Reporter = Reporter()
+
     var session: URLSession?
-    var pendingUploadEvent: UploadEvent?
+
+    var pendingEvents: [ObjectIdentifier: Codable] = [:]
 
     var jsonEncoder: JSONEncoder
 
+    var sessionID: String = UUID().uuidString
+    var url: URL
+
     // TODO: Set these using dependency Injection
     var locale: Locale {
         Locale.current
@@ -33,83 +40,244 @@ class Reporter: NSObject {
         let jsonEncoder = JSONEncoder()
         jsonEncoder.keyEncodingStrategy = JSONEncoder.KeyEncodingStrategy.convertToSnakeCase
         jsonEncoder.outputFormatting = .sortedKeys
+        jsonEncoder.dateEncodingStrategy = .iso8601
         self.jsonEncoder = jsonEncoder
 
+        // TODO: throwable initializer after NSObject super
+        // is removed
+        self.url = URL(
+            string: "https://mobile.muxanalytics.com"
+        )!
+
         super.init()
 
         let sessionConfig: URLSessionConfiguration = URLSessionConfiguration.default
         session = URLSession(configuration: sessionConfig, delegate: self, delegateQueue: nil)
     }
 
-    func report(
-        startTime: TimeInterval,
-        endTime: TimeInterval,
-        fileSize: UInt64,
-        videoDuration: Double,
+    func send<Event: Codable>(
+        event: Event,
+        url: URL
+    ) {
+        guard let httpBody = try? jsonEncoder.encode(event) else {
+            return
+        }
+
+        let request = NSMutableURLRequest.makeJSONPost(
+            url: url,
+            httpBody: httpBody
+        )
+
+        guard let dataTask = session?.dataTask(
+            with: request as URLRequest
+        ) else {
+            return
+        }
+
+        let taskID = ObjectIdentifier(dataTask)
+
+        pendingEvents[
+            taskID
+        ] = event
+
+        dataTask.resume()
+    }
+}
+
+extension Reporter {
+    func reportUploadSuccess(
+        inputDuration: Double,
+        inputSize: UInt64,
+        options: UploadOptions,
+        uploadEndTime: Date,
+        uploadStartTime: Date,
         uploadURL: URL
     ) -> Void {
-        self.pendingUploadEvent = UploadEvent(
-            startTime: startTime,
-            endTime: endTime,
-            fileSize: fileSize,
-            videoDuration: videoDuration,
-            uploadURL: uploadURL,
-            sdkVersion: Version.versionString,
-            osName: device.systemName,
-            osVersion: device.systemVersion,
+
+        guard !options.eventTracking.optedOut else {
+            return
+        }
+
+        let data = UploadSucceededEvent.Data(
+            appName: Bundle.main.appName,
+            appVersion: Bundle.main.appVersion,
             deviceModel: device.model,
-            appName: Bundle.main.bundleIdentifier,
+            inputDuration: inputDuration,
+            inputSize: inputSize,
+            inputStandardizationEnabled: options.inputStandardization.isEnabled,
+            platformName: device.systemName,
+            platformVersion: device.systemVersion,
+            regionCode: regionCode,
+            sdkVersion: Version.versionString,
+            uploadStartTime: uploadStartTime,
+            uploadEndTime: uploadEndTime,
+            uploadURL: uploadURL
+        )
+
+        let event = UploadSucceededEvent(
+            sessionID: sessionID,
+            data: data
+        )
+
+        send(
+            event: event,
+            url: url
+        )
+    }
+
+    func reportUploadFailure(
+        errorDescription: String,
+        inputDuration: Double,
+        inputSize: UInt64,
+        options: UploadOptions,
+        uploadEndTime: Date,
+        uploadStartTime: Date,
+        uploadURL: URL
+    ) {
+        guard !options.eventTracking.optedOut else {
+            return
+        }
+
+        let data = UploadFailedEvent.Data(
+            appName: Bundle.main.appName,
             appVersion: Bundle.main.appVersion,
-            regionCode: regionCode
+            deviceModel: device.model,
+            errorDescription: errorDescription,
+            inputDuration: inputDuration,
+            inputSize: inputSize,
+            inputStandardizationEnabled: options.inputStandardization.isEnabled,
+            platformName: device.systemName,
+            platformVersion: device.systemVersion,
+            regionCode: regionCode,
+            sdkVersion: Version.versionString,
+            uploadStartTime: uploadStartTime,
+            uploadEndTime: uploadEndTime,
+            uploadURL: url
         )
 
-        // FIXME: If this fails, an event without a payload
-        // is sent which probably isn't what we want
-        do {
-            let httpBody = try serializePendingEvent()
-            let request = self.generateRequest(
-                url: URL(string: "https://mobile.muxanalytics.com")!,
-                httpBody: httpBody
-            )
-            let dataTask = session?.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
-                self.pendingUploadEvent = nil
-            })
-            dataTask?.resume()
-        } catch _ as NSError {}
+        let event = UploadFailedEvent(
+            sessionID: sessionID,
+            data: data
+        )
+
+        send(
+            event: event,
+            url: url
+        )
     }
 
-    func serializePendingEvent() throws -> Data {
-        return try jsonEncoder.encode(pendingUploadEvent)
+    func reportUploadInputStandardizationSuccess(
+        inputDuration: Double,
+        inputSize: UInt64,
+        options: UploadOptions,
+        nonStandardInputReasons: [String],
+        standardizationEndTime: Date,
+        standardizationStartTime: Date,
+        uploadURL: URL
+    ) {
+        guard !options.eventTracking.optedOut else {
+            return
+        }
+
+        let data = InputStandardizationSucceededEvent.Data(
+            appName: Bundle.main.appName,
+            appVersion: Bundle.main.appVersion,
+            deviceModel: device.model,
+            inputDuration: inputDuration,
+            inputSize: inputSize,
+            maximumResolution: options.inputStandardization.maximumResolution.description,
+            nonStandardInputReasons: nonStandardInputReasons,
+            platformName: device.systemName,
+            platformVersion: device.systemVersion,
+            regionCode: regionCode,
+            sdkVersion: Version.versionString,
+            standardizationStartTime: standardizationStartTime,
+            standardizationEndTime: standardizationEndTime,
+            uploadURL: uploadURL
+        )
+
+        let event = InputStandardizationSucceededEvent(
+            sessionID: sessionID,
+            data: data
+        )
+
+        send(
+            event: event,
+            url: url
+        )
     }
 
-    private func generateRequest(
-        url: URL,
-        httpBody: Data
-    ) -> URLRequest {
-        let request = NSMutableURLRequest(url: url,
-                                          cachePolicy: .useProtocolCachePolicy,
-                                          timeoutInterval: 10.0)
-        request.httpMethod = "POST"
-        request.setValue("application/json", forHTTPHeaderField: "Accept")
-        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
-        request.httpBody = httpBody
-
-        return request as URLRequest
+    func reportUploadInputStandardizationFailure(
+        errorDescription: String,
+        inputDuration: Double,
+        inputSize: UInt64,
+        nonStandardInputReasons: [String],
+        options: UploadOptions,
+        standardizationEndTime: Date,
+        standardizationStartTime: Date,
+        uploadCanceled: Bool,
+        uploadURL: URL
+    ) {
+        guard !options.eventTracking.optedOut else {
+            return
+        }
+
+        let data = InputStandardizationFailedEvent.Data(
+            appName: Bundle.main.appName,
+            appVersion: Bundle.main.appVersion,
+            deviceModel: device.model,
+            errorDescription: errorDescription,
+            inputDuration: inputDuration,
+            inputSize: inputSize,
+            maximumResolution: options.inputStandardization.maximumResolution.description,
+            nonStandardInputReasons: nonStandardInputReasons,
+            platformName: device.systemName,
+            platformVersion: device.systemVersion,
+            regionCode: regionCode,
+            sdkVersion: Version.versionString,
+            standardizationStartTime: standardizationStartTime,
+            standardizationEndTime: standardizationEndTime,
+            uploadCanceled: uploadCanceled,
+            uploadURL: uploadURL
+        )
+
+        let event = InputStandardizationFailedEvent(
+            sessionID: sessionID,
+            data: data
+        )
+
+        send(
+            event: event,
+            url: url
+        )
     }
 }
 
 // TODO: Implement as a separate object so the URLSession
 // can become non-optional, which removes a bunch of edge cases
 extension Reporter: URLSessionDelegate, URLSessionTaskDelegate {
     func urlSession(_ session: URLSession, task: URLSessionTask, willPerformHTTPRedirection response: HTTPURLResponse, newRequest request: URLRequest, completionHandler: @escaping (URLRequest?) -> Swift.Void) {
-        if(self.pendingUploadEvent != nil) {
-            if let redirectUrl = request.url, let httpBody = try? serializePendingEvent() {
-                let request = self.generateRequest(
-                    url: redirectUrl,
-                    httpBody: httpBody
-                )
-                completionHandler(request)
+        if let pendingEvent = pendingEvents[ObjectIdentifier(task)], let redirectURL = request.url {
+            guard let httpBody = try? jsonEncoder.encode(pendingEvent) else {
+                completionHandler(nil)
+                return
             }
+
+            // TODO: This can be URLRequest instead of NSMutableURLRequest
+            // test URLRequest-based construction in case
+            // for any weirdness
+            let request = NSMutableURLRequest.makeJSONPost(
+                url: redirectURL,
+                httpBody: httpBody
+            )
+
+            completionHandler(request as URLRequest)
         }
     }
+
+    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+        pendingEvents[
+            ObjectIdentifier(task)
+        ] = nil
+    }
 }