updates

Author: Brandon Sneed

.swiftpm/xcode/xcshareddata/xcschemes/segmentcli.xcscheme

@@ -93,6 +93,10 @@
          </CommandLineArgument>
          <CommandLineArgument
             argument = "analytics track Sf37SZu7TfysLklHCahTo5HlSP9m9O6h someGoofyEvent myBool=true myNumber=5 myFloat=3.14 myString=&quot;get schwifty&quot;"
+            isEnabled = "NO">
+         </CommandLineArgument>
+         <CommandLineArgument
+            argument = "analytics flush Sf37SZu7TfysLklHCahTo5HlSP9m9O6h"
             isEnabled = "YES">
          </CommandLineArgument>
          <CommandLineArgument

Package.resolved

@@ -18,7 +18,9 @@ class AnalyticsGroup: CommandGroup {
                                 AnalyticsScreenCommand(),
                                 AnalyticsGroupCommand(),
                                 AnalyticsAliasCommand(),
-                                AnalyticsResetCommand()]
+                                AnalyticsResetCommand(),
+                                AnalyticsFlushCommand(),
+                                AnalyticsListCommand()]
     init() {}
 }
 
@@ -61,25 +63,31 @@ class AnalyticsTrackCommand: Command {
     @Param var writeKey: String
     @Param var eventName: String
 
+    @Flag("-f", "--flush", description: "Flush event(s) to Segment before returning")
+    var flush: Bool
+    
     @CollectedParam(minCount: 0, validation: keyValueValidation) var properties: [String]
 
     func execute() throws {
         let spinner = Spinner(.dots, "Sending track event to Segment ...")
         spinner.start()
 
-        let config = Configuration(writeKey: writeKey)
-        config.flushAt(1)
+        let analytics = Analytics(configuration: Configuration(writeKey: writeKey))
+        analytics.waitUntilStarted()
 
-        let analytics = Analytics(configuration: config)
         executeAndWait { semaphore in
             analytics.track(name: eventName, properties: paramArryToDictionary(properties))
-            // wait for the event to enter the system
+            // wait till we know the event has been placed in the queue
             while analytics.hasUnsentEvents == false {
                 RunLoop.main.run(until: Date.distantPast)
             }
-            // wait for it to exit
-            while analytics.hasUnsentEvents {
-                RunLoop.main.run(until: Date.distantPast)
+            if flush {
+                analytics.flush()
+                // wait for flush to complete
+                while analytics.hasUnsentEvents {
+                    analytics.flush()
+                    RunLoop.main.run(until: Date.distantPast)
+                }
             }
             semaphore.signal()
         }
@@ -95,30 +103,36 @@ class AnalyticsIdentifyCommand: Command {
 
     @Param var writeKey: String
     @Param var userID: String
-    
+        
+    @Flag("-f", "--flush", description: "Flush event(s) to Segment before returning")
+    var flush: Bool
+
     @CollectedParam(minCount: 0, validation: keyValueValidation) var traits: [String]
 
     func execute() throws {
         let spinner = Spinner(.dots, "Sending identify event to Segment ...")
         spinner.start()
 
-        let config = Configuration(writeKey: writeKey)
-        config.flushAt(1)
+        let analytics = Analytics(configuration: Configuration(writeKey: writeKey))
+        analytics.waitUntilStarted()
 
-        let analytics = Analytics(configuration: config)
         executeAndWait { semaphore in
-            analytics.identify(userId: userID, traits: paramArryToDictionary(traits))
-            // wait for the event to enter the system
+            analytics.identify(userId, traits: paramArryToDictionary(traits))
+            // wait till we know the event has been placed in the queue
             while analytics.hasUnsentEvents == false {
                 RunLoop.main.run(until: Date.distantPast)
             }
-            // wait for it to exit
-            while analytics.hasUnsentEvents {
-                RunLoop.main.run(until: Date.distantPast)
+            if flush {
+                analytics.flush()
+                // wait for flush to complete
+                while analytics.hasUnsentEvents {
+                    analytics.flush()
+                    RunLoop.main.run(until: Date.distantPast)
+                }
             }
             semaphore.signal()
         }
-        
+
         spinner.stop()
         print("Identify Event for `\(userID)` sent!\n")
     }
@@ -128,31 +142,205 @@ class AnalyticsScreenCommand: Command {
     let name = "screen"
     let shortDescription = "Send a screen event to Segment"
 
+    @Param var writeKey: String
+    @Param var eventName: String
+    
+    @Flag("-f", "--flush", description: "Flush event(s) to Segment before returning")
+    var flush: Bool
+    
+    @CollectedParam(minCount: 0, validation: keyValueValidation) var properties: [String]
+    
     func execute() throws {
+        let spinner = Spinner(.dots, "Sending track event to Segment ...")
+        spinner.start()
+        
+        Analytics.debugLogsEnabled = true
+        let analytics = Analytics(configuration: Configuration(writeKey: writeKey))
+        
+        analytics.waitUntilStarted()
+        
+        executeAndWait { semaphore in
+            analytics.track(name: eventName, properties: paramArryToDictionary(properties))
+            // wait till we know the event has been placed in the queue
+            while analytics.hasUnsentEvents == false {
+                RunLoop.main.run(until: Date.distantPast)
+            }
+            if flush {
+                analytics.flush()
+                // wait for flush to complete
+                while analytics.hasUnsentEvents {
+                    analytics.flush()
+                    RunLoop.main.run(until: Date.distantPast)
+                }
+            }
+            semaphore.signal()
+        }
+        
+        spinner.stop()
+        print("Event `\(eventName)` sent!\n")
     }
 }
 
 class AnalyticsGroupCommand: Command {
     let name = "group"
     let shortDescription = "Send a group event to Segment"
 
+    @Param var writeKey: String
+    @Param var eventName: String
+    
+    @Flag("-f", "--flush", description: "Flush event(s) to Segment before returning")
+    var flush: Bool
+    
+    @CollectedParam(minCount: 0, validation: keyValueValidation) var properties: [String]
+    
     func execute() throws {
+        let spinner = Spinner(.dots, "Sending track event to Segment ...")
+        spinner.start()
+        
+        Analytics.debugLogsEnabled = true
+        let analytics = Analytics(configuration: Configuration(writeKey: writeKey))
+        
+        analytics.waitUntilStarted()
+        
+        executeAndWait { semaphore in
+            analytics.track(name: eventName, properties: paramArryToDictionary(properties))
+            // wait till we know the event has been placed in the queue
+            while analytics.hasUnsentEvents == false {
+                RunLoop.main.run(until: Date.distantPast)
+            }
+            if flush {
+                analytics.flush()
+                // wait for flush to complete
+                while analytics.hasUnsentEvents {
+                    analytics.flush()
+                    RunLoop.main.run(until: Date.distantPast)
+                }
+            }
+            semaphore.signal()
+        }
+        
+        spinner.stop()
+        print("Event `\(eventName)` sent!\n")
     }
 }
 
 class AnalyticsAliasCommand: Command {
     let name = "alias"
     let shortDescription = "Send an alias event to Segment"
 
+    @Param var writeKey: String
+    @Param var eventName: String
+    
+    @Flag("-f", "--flush", description: "Flush event(s) to Segment before returning")
+    var flush: Bool
+    
+    @CollectedParam(minCount: 0, validation: keyValueValidation) var properties: [String]
+    
     func execute() throws {
+        let spinner = Spinner(.dots, "Sending track event to Segment ...")
+        spinner.start()
+        
+        Analytics.debugLogsEnabled = true
+        let analytics = Analytics(configuration: Configuration(writeKey: writeKey))
+        
+        analytics.waitUntilStarted()
+        
+        executeAndWait { semaphore in
+            analytics.track(name: eventName, properties: paramArryToDictionary(properties))
+            // wait till we know the event has been placed in the queue
+            while analytics.hasUnsentEvents == false {
+                RunLoop.main.run(until: Date.distantPast)
+            }
+            if flush {
+                analytics.flush()
+                // wait for flush to complete
+                while analytics.hasUnsentEvents {
+                    analytics.flush()
+                    RunLoop.main.run(until: Date.distantPast)
+                }
+            }
+            semaphore.signal()
+        }
+        
+        spinner.stop()
+        print("Event `\(eventName)` sent!\n")
     }
 }
 
 class AnalyticsResetCommand: Command {
     let name = "reset"
     let shortDescription = "Resets any stored data like anonID, userID, etc"
 
+    @Param var writeKey: String
+    
+    @Flag("-h", "--hard", description: "Removes any pending event batches as well")
+    var hard: Bool
+
+    func execute() throws {
+        let analytics = Analytics(configuration: Configuration(writeKey: writeKey))
+        analytics.waitUntilStarted()
+        
+        analytics.reset()
+        
+        if hard {
+            let allFiles = try? FileManager.default.contentsOfDirectory(at: eventStorageDirectory(writeKey: writeKey), includingPropertiesForKeys: [], options: .skipsHiddenFiles)
+            if let files = allFiles, files.count > 0 {
+                for file in files {
+                    try? FileManager.default.removeItem(at: file)
+                }
+            }
+        }
+        
+        print("\nSystem has been reset.")
+    }
+}
+
+class AnalyticsFlushCommand: Command {
+    let name = "flush"
+    let shortDescription = "Flush any locally pending events out to Segment"
+    
+    @Param var writeKey: String
+
     func execute() throws {
+        let spinner = Spinner(.dots, "Flushing events to Segment ...")
+        spinner.start()
+        
+        let analytics = Analytics(configuration: Configuration(writeKey: writeKey))
+        analytics.waitUntilStarted()
+        
+        executeAndWait { semaphore in
+            analytics.flush()
+            // wait for it to exit
+            while analytics.hasUnsentEvents {
+                RunLoop.main.run(until: Date.distantPast)
+            }
+            semaphore.signal()
+        }
+        
+        spinner.stop()
+        print("All pending events have been sent!\n")
+    }
+}
+
+class AnalyticsListCommand: Command {
+    let name = "list"
+    let shortDescription = "List currently pending event batches"
+    
+    @Param var writeKey: String
+
+    func execute() throws {
+        let analytics = Analytics(configuration: Configuration(writeKey: writeKey))
+        analytics.waitUntilStarted()
+        
+        let files = analytics.pendingUploads
+        if let files = files, files.count > 0 {
+            print("\n\nPending event batches:\n")
+            for file in files {
+                print("    \(file.path)")
+            }
+        } else {
+            print("\nThere are no pending event batches to be sent.")
+        }
     }
 }
 

Sources/segmentcli/Commands/Analytics.swift

@@ -7,6 +7,7 @@
 
 import Foundation
 import SwiftCLI
+import Segment
 
 // MARK: - Helper methods
 
@@ -48,3 +49,14 @@ func exitWithError(_ error: Error) {
 // useful for error handling
 extension String: Error {}
 
+// MARK: - Segment helper functions
+
+func eventStorageDirectory(writeKey: String) -> URL {
+    let urls = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)
+    let docURL = urls[0]
+    let segmentURL = docURL.appendingPathComponent("segment/\(writeKey)/")
+    // try to create it, will fail if already exists, nbd.
+    // tvOS, watchOS regularly clear out data.
+    try? FileManager.default.createDirectory(at: segmentURL, withIntermediateDirectories: true, attributes: nil)
+    return segmentURL
+}