Offline support

Author: krml19

.gitignore

@@ -21,6 +21,7 @@ xcuserdata/
 *.moved-aside
 *.xccheckout
 *.xcscmblueprint
+.DS_Store
 
 ## Obj-C/Swift specific
 *.hmap

Backtrace.podspec

@@ -9,7 +9,7 @@
 Pod::Spec.new do |s|
 
   s.name         = "Backtrace"
-  s.version      = "1.0.0"
+  s.version      = "1.1.0"
   s.summary      = "Backtrace's integration with iOS and macOS"
   s.description  = "Backtrace's integration with iOS and macOS for handling crashes"
   s.homepage     = "https://backtrace.io/"
@@ -27,7 +27,7 @@ Pod::Spec.new do |s|
   s.osx.public_header_files = ["Backtrace-macOS/**/*.h*"]
 
   s.dependency "Backtrace-PLCrashReporter"
-
+  s.resources = 'Sources/**/*.xcdatamodeld'
 
   s.swift_version = '4.0'
 end

Backtrace.xcodeproj/project.pbxproj

@@ -1,7 +1,7 @@
 #import "AppDelegate.h"
 @import Backtrace;
 
-@interface AppDelegate ()
+@interface AppDelegate () <BacktraceClientDelegate>
 
 @end
 
@@ -12,6 +12,8 @@ - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(
                                          initWithEndpoint: [NSURL URLWithString: @"https://backtrace.io"]
                                          token: @""];
     [BacktraceClient.shared registerWithCredentials: credentials];
+    
+    BacktraceClient.shared.delegate = self;
 
     // sending NSException
     @try {
@@ -34,4 +36,25 @@ - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(
     return YES;
 }
 
+#pragma mark - BacktraceClientDelegate
+- (BacktraceCrashReport *)willSend:(BacktraceCrashReport *)report {
+    return report;
+}
+
+- (void)serverDidFail:(NSError *)error {
+    
+}
+
+- (void)serverDidResponse:(BacktraceResult *)result {
+    
+}
+
+- (NSURLRequest *)willSendRequest:(NSURLRequest *)request {
+    return request;
+}
+
+- (void)didReachLimit:(BacktraceResult *)result {
+    
+}
+
 @end

Example-iOS-ObjC/AppDelegate.m

@@ -19,6 +19,7 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
         let backtraceCredentials = BacktraceCredentials(endpoint: URL(string: "https://backtrace.io")!,
                                                         token: "")
         BacktraceClient.shared.register(credentials: backtraceCredentials)
+        BacktraceClient.shared.delegate = self
 
         do {
             try throwingFunc()
@@ -31,3 +32,25 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
         return true
     }
 }
+
+extension AppDelegate: BacktraceClientDelegate {
+    func willSend(_ report: BacktraceCrashReport) -> (BacktraceCrashReport) {
+        return report
+    }
+    
+    func willSendRequest(_ request: URLRequest) -> URLRequest {
+        return request
+    }
+    
+    func serverDidFail(_ error: Error) {
+        
+    }
+    
+    func serverDidResponse(_ result: BacktraceResult) {
+        
+    }
+    
+    func didReachLimit(_ result: BacktraceResult) {
+        
+    }
+}

Example-iOS/AppDelegate.swift

@@ -123,6 +123,46 @@ BacktraceClient.shared.register(credentials: BacktraceCredentials)
 [[BacktraceClient shared] registerWithCredentials: BacktraceCredentials];
 ```
 
+## Backtrace client configuration
+For more advanced usage of BacktraceClient, you can supply BacktraceClientConfiguration as a parameter. See the following example:
+```swift
+let backtraceCredentials = BacktraceCredentials(endpoint: URL(string: "backtrace_endpoint_url")!,
+                                                token: "token")
+let backtraceConfiguration = BacktraceClientConfiguration(credentials: backtraceCredentials,
+                                                          dbSettings: BacktraceDatabaseSettings(),
+                                                          reportsPerMin: 10)
+BacktraceClient.shared.register(configuration: backtraceConfiguration)
+```
+
+### Database settings
+BacktraceClient allows you to customize the initialization of BacktraceDatabase for local storage of error reports by supplying a BacktraceDatabaseSettings parameter, as follows:
+```swift
+let backtraceCredentials = BacktraceCredentials(endpoint: URL(string: "backtrace_endpoint_url")!,
+                                                token: "token")
+let backtraceDatabaseSettings = BacktraceDatabaseSettings()
+backtraceDatabaseSettings.maxRecordCount = 1000
+backtraceDatabaseSettings.maxDatabaseSize = 10
+backtraceDatabaseSettings.retryInterval = 5
+backtraceDatabaseSettings.retryLimit = 3
+backtraceDatabaseSettings.retryBehaviour = RetryBehaviour.interval
+backtraceDatabaseSettings.retryOrder = RetryOder.queue
+let backtraceConfiguration = BacktraceClientConfiguration(credentials: backtraceCredentials,
+                                                          dbSettings: backtraceDatabaseSettings,
+                                                          reportsPerMin: 10)
+BacktraceClient.shared.register(configuration: backtraceConfiguration)
+```
+
+### Events handling
+BacktraceClient allows you to subscribe for events produced before and after sending error report:
+- Swift
+```swift
+func willSend(_ report: BacktraceCrashReport) -> (BacktraceCrashReport)
+func willSendRequest(_ request: URLRequest) -> URLRequest
+func serverDidFail(_ error: Error)
+func serverDidResponse(_ result: BacktraceResult)
+func didReachLimit(_ result: BacktraceResult)
+```
+
 ## Sending an error report <a name="documentation-sending-report"></a>
 Registered `BacktraceClient` will be able to send an crash reports. Error report is automatically generated based.
 

README.md

@@ -4,27 +4,39 @@ class BacktraceRegisteredClient {
 
     private let reporter: CrashReporting
     private var networkClient: NetworkClientType
-    private let repository = InMemoryRepository<BacktraceCrashReport>()
-
-    init(reporter: CrashReporting = CrashReporter(), networkClient: NetworkClientType) {
+    private let repository: PersistentRepository<BacktraceCrashReport>
+    private let watcher: BacktraceWatcher<PersistentRepository<BacktraceCrashReport>>
+    
+    init(reporter: CrashReporting = CrashReporter(),
+         networkClient: NetworkClientType,
+         dbSettings: BacktraceDatabaseSettings,
+         reportsPerMin: Int) throws {
         self.reporter = reporter
         self.networkClient = networkClient
+        self.repository = try PersistentRepository<BacktraceCrashReport>(settings: dbSettings)
+        self.watcher = try BacktraceWatcher(settings: dbSettings,
+                                            reportsPerMin: reportsPerMin,
+                                            networkClient: networkClient,
+                                            repository: repository)
     }
 }
 
 extension BacktraceRegisteredClient: BacktraceClientType {
 
     func handlePendingCrashes() throws {
+        // always try to remove pending crash report from disk
+        defer { try? reporter.purgePendingCrashReport() }
+
+        // enable crash reporting
         try reporter.enableCrashReporting()
+
+        // try to send pending crash report
         guard reporter.hasPendingCrashes() else {
             BacktraceLogger.debug("No pending crashes")
             return
         }
         let resource = try reporter.pendingCrashReport()
-        try repository.save(resource)
-        try networkClient.send(resource.reportData)
-        try repository.delete(resource)
-        try reporter.purgePendingCrashReport()
+        _ = try send(resource)
     }
 
     func send(_ exception: NSException? = nil) throws -> BacktraceResult {
@@ -34,9 +46,19 @@ extension BacktraceRegisteredClient: BacktraceClientType {
         } else {
             resource = try reporter.generateLiveReport()
         }
-        try repository.save(resource)
-        let result = try networkClient.send(resource.reportData)
-        try repository.delete(resource)
-        return result.backtraceResult
+        return try send(resource)
+    }
+    
+    private func send(_ resource: BacktraceCrashReport) throws -> BacktraceResult {
+        do {
+            let result = try networkClient.send(resource)
+            if result.backtraceStatus != .ok, let report = result.backtraceData {
+                try repository.save(report)
+            }
+            return result
+        } catch let error as BacktraceErrorResponse {
+            try repository.save(resource)
+            throw error
+        }
     }
 }

Sources/Client/BacktraceRegisteredClient.swift

@@ -1,15 +1,19 @@
 import Foundation
 
-struct BacktraceHtttpResponseDeserializer {
-    let response: BacktraceResponse
+enum Result<T, E: Error> {
+    case success(T)
+    case error(E)
+}
+
+struct BacktraceHttpResponseDeserializer {
+    let result: Result<BacktraceResponse, BacktraceErrorResponse>
 
     init(httpResponse: HTTPURLResponse, responseData: Data) throws {
         let jsonDeserializer = JSONDecoder()
         if httpResponse.isSuccess {
-            self.response = (try jsonDeserializer.decode(BacktraceResponse.self, from: responseData))
+            self.result = .success(try jsonDeserializer.decode(BacktraceResponse.self, from: responseData))
         } else {
-            let errorResponse = try jsonDeserializer.decode(BacktraceErrorResponse.self, from: responseData)
-            throw errorResponse
+            self.result = .error(try jsonDeserializer.decode(BacktraceErrorResponse.self, from: responseData))
         }
     }
 }
@@ -27,8 +31,8 @@ struct BacktraceResponse: Codable {
 }
 
 extension BacktraceResponse {
-    var backtraceResult: BacktraceResult {
-        return BacktraceResult(.ok(response: response))
+    func result(backtraceReport: BacktraceCrashReport) -> BacktraceResult {
+        return BacktraceResult(.ok, message: "Ok.", backtraceReport: backtraceReport)
     }
 }
 
@@ -42,8 +46,8 @@ struct BacktraceErrorResponse: Codable, BacktraceError {
 }
 
 extension BacktraceErrorResponse {
-    var backtraceResult: BacktraceResult {
-        return BacktraceResult(.serverError(message: error.message, code: error.code))
+    func result(backtraceReport: BacktraceCrashReport) -> BacktraceResult {
+        return BacktraceResult(.serverError, message: error.message, backtraceReport: backtraceReport)
     }
 }
 

Sources/Client/BacktraceResponse.swift

@@ -2,8 +2,8 @@ import Foundation
 
 class BacktraceUnregisteredClient: BacktraceClientType {
     private static let printBlock = { () -> BacktraceResult in
-        BacktraceLogger.error("Backtrace client is not regiestered.")
-        return BacktraceResult(.notRegisterd)
+        BacktraceLogger.error("Backtrace client is not registered.")
+        return BacktraceResult(.notRegistered, message: "Backtrace client is not registered.")
     }
 
     func handlePendingCrashes() throws {

Sources/Client/BacktraceUnregisteredClient.swift

@@ -22,16 +22,12 @@ class CrashReporter: NSObject {
 extension CrashReporter: CrashReporting {
     func generateLiveReport(exception: NSException) throws -> BacktraceCrashReport {
         let reportData = try reporter.generateLiveReport(with: exception)
-        let report = try PLCrashReport(data: reportData)
-        BacktraceLogger.debug("Live report: \n\(report.info)")
-        return BacktraceCrashReport(report: reportData, hashValue: report.uuidRef?.hashValue)
+        return try BacktraceCrashReport(report: reportData)
     }
 
     func generateLiveReport() throws -> BacktraceCrashReport {
         let reportData = try reporter.generateLiveReportAndReturnError()
-        let report = try PLCrashReport(data: reportData)
-        BacktraceLogger.debug("Live report: \n\(report.info)")
-        return BacktraceCrashReport(report: reportData, hashValue: report.uuidRef?.hashValue)
+        return try BacktraceCrashReport(report: reportData)
     }
 
     func enableCrashReporting() throws {
@@ -40,9 +36,7 @@ extension CrashReporter: CrashReporting {
 
     func pendingCrashReport() throws -> BacktraceCrashReport {
         let reportData = try reporter.loadPendingCrashReportDataAndReturnError()
-        let report = try PLCrashReport(data: reportData)
-        BacktraceLogger.debug("Pending crash: \n\(report.info)")
-        return BacktraceCrashReport(report: reportData, hashValue: report.uuidRef?.hashValue)
+        return try BacktraceCrashReport(report: reportData)
     }
 
     func hasPendingCrashes() -> Bool {