Merge pull request #101 from tonystone/fixed-protected-data

Add protected data monitoring for fixed FileWriter strategy on iOS

Author: tonystone

CHANGELOG.md

@@ -1,6 +1,11 @@
 # Change Log
 All significant changes to this project will be documented in this file.
 
+## [5.0.0-beta.3](https://github.com/tonystone/tracelog/tree/5.0.0-beta.3)
+
+#### Added
+- Added protected data monitoring for `FileWriter.Strategy.fixed` on iOS for use with `AsyncConcurrencyModeOption.buffer(writeInterval:strategy:)`.  This allows TraceLog to be started up before protected data is available on iOS.
+
 ## [5.0.0-beta.2](https://github.com/tonystone/tracelog/tree/5.0.0-beta.2)
 
 #### Changed

README.md

@@ -51,6 +51,7 @@
     * **TextFormat** a customizable human readable text formatter useable with any `OutputStreamWriter`.
     * **JSONFormat** a customizable JSON string formatter usable with any `OutputStreamWriter`.
  - [x] Create custom output formatters for any use case.
+ - [x] An output buffering mode to buffer output when a writer is unavailable (e.g. on iOS when protected data is not available).
  - [x] Multiple **concurrency modes** for writing to Writers. Settable globally or per Writer installed.
    * **direct** - straight through real-time logging.
    * **sync** - blocking queued logging.

Sources/TraceLog/ConcurrencyMode.swift

@@ -164,11 +164,11 @@ public enum AsyncConcurrencyModeOption {
     /// will write each log entry in the buffer (in order) until the end of the
     /// buffer or the Writer becomes unavailable again.
     ///
-    /// Buffering is useful for many different use case including:
+    /// - Remark: Buffering is useful for many different use case including:
     ///
-    /// E.g. In an iOS application when protected data is not available to your
+    ///      In an iOS application when protected data is not available to your
     ///      app but you require visibility into the apps logging even during
-    ////     these times.
+    ///      these times.
     ///
     ///      A network writer when the network connection is unavailable for any reason.
     ///

Sources/TraceLog/Writers & Formatters/JSONFormat.swift renamed to Sources/TraceLog/Formatters/JSONFormat.swift

@@ -51,6 +51,7 @@ internal class AsyncWriterProxy: WriterProxy {
             switch option {
 
             /// Enable buffering
+            ///
             case ._buffer(let writeInterval, let strategy):
 
                 let writeTimer = BlockTimer(deadline: .now() + writeInterval, repeating: writeInterval, queue: self.queue)
@@ -189,6 +190,7 @@ private class LogEntryQueue {
         }
 
         /// Now add the new element
+        ///
         storage.append(element)
     }
 
@@ -204,4 +206,3 @@ private class LogEntryQueue {
         return storage[0]
     }
 }
-

Sources/TraceLog/Writers & Formatters/TextFormat.swift renamed to Sources/TraceLog/Formatters/TextFormat.swift

@@ -0,0 +1,81 @@
+///
+///  FileStrategy+Fixed.swift
+///
+///  Copyright 2019 Tony Stone
+///
+///  Licensed under the Apache License, Version 2.0 (the "License");
+///  you may not use this file except in compliance with the License.
+///  You may obtain a copy of the License at
+///
+///  http://www.apache.org/licenses/LICENSE-2.0
+///
+///  Unless required by applicable law or agreed to in writing, software
+///  distributed under the License is distributed on an "AS IS" BASIS,
+///  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+///  See the License for the specific language governing permissions and
+///  limitations under the License.
+///
+///  Created by Tony Stone on 1/31/19.
+///
+import Foundation
+
+@available(iOSApplicationExtension, unavailable)
+internal class FileStrategyFixed: FileStrategyManager {
+
+    let url: URL
+
+    private var stream: FileOutputStream
+    private var available: Bool
+
+    init(directory: URL, fileName: String) throws {
+
+        self.url       = directory.appendingPathComponent(fileName)
+        self.available = isLogAvailable()
+        self.stream    = try FileOutputStream(url: url, options: [.create])
+
+        #if os(iOS) && !targetEnvironment(simulator)
+        /// Note: You can create empty files with file protection in any state.  You just cant write or read from them.
+        ///       We can safely create the file and set it's protection level even if not available.
+        ///
+        try FileManager.default.setAttributes([.protectionKey : FileProtectionType.completeUntilFirstUserAuthentication], ofItemAtPath: url.path)
+
+        if !available {
+            NotificationCenter.default.addObserver(forName: UIApplication.protectedDataDidBecomeAvailableNotification, object: nil, queue: nil) { (_) in
+                if !self.available {
+                    self.available = true
+                }
+            }
+        }
+        #endif
+    }
+    deinit {
+        self.stream.close()
+    }
+
+    func write(_ bytes: [UInt8]) -> Result<Int, FailureReason> {
+
+        guard self.available
+            else { return .failure(.unavailable) }
+
+        return stream.write(bytes).mapError({ self.failureReason($0) })
+    }
+}
+
+#if os(iOS) && !targetEnvironment(simulator)
+import UIKit
+
+@available(iOSApplicationExtension, unavailable)
+func isLogAvailable() -> Bool {
+    if !Thread.isMainThread {
+        return DispatchQueue.main.sync {
+            return UIApplication.shared.isProtectedDataAvailable
+        }
+    }
+    return UIApplication.shared.isProtectedDataAvailable
+}
+#else
+
+func isLogAvailable() -> Bool {
+    return true
+}
+#endif