motion-yapper 0.0.1 → 0.0.2

data/vendor/Pods/CocoaLumberjack/Lumberjack/DDFileLogger.h

@@ -7,10 +7,10 @@
  * Welcome to Cocoa Lumberjack!
  * 
  * The project page has a wealth of documentation if you have any questions.
- * https://github.com/robbiehanson/CocoaLumberjack
+ * https://github.com/CocoaLumberjack/CocoaLumberjack
  * 
  * If you're new to the project you may wish to read the "Getting Started" wiki.
- * https://github.com/robbiehanson/CocoaLumberjack/wiki/GettingStarted
+ * https://github.com/CocoaLumberjack/CocoaLumberjack/wiki/GettingStarted
  * 
  * 
  * This class provides a logger to write log statements to a file.
@@ -108,19 +108,47 @@
  * On Mac, this is in ~/Library/Logs/<Application Name>.
  * On iPhone, this is in ~/Library/Caches/Logs.
  * 
- * Log files are named "log-<uuid>.txt",
- * where uuid is a 6 character hexadecimal consisting of the set [0123456789ABCDEF].
+ * Log files are named "<bundle identifier> <date> <time>.log"
+ * Example: com.organization.myapp 2013-12-03 17-14.log
  * 
  * Archived log files are automatically deleted according to the maximumNumberOfLogFiles property.
 **/
 @interface DDLogFileManagerDefault : NSObject <DDLogFileManager>
 {
-	NSUInteger maximumNumberOfLogFiles;
-	NSString *_logsDirectory;
+    NSUInteger maximumNumberOfLogFiles;
+    NSString *_logsDirectory;
 }
 
 - (id)init;
-- (id)initWithLogsDirectory:(NSString *)logsDirectory;
+- (instancetype)initWithLogsDirectory:(NSString *)logsDirectory;
+
+/*
+ * Methods to override.
+ *
+ * Log files are named "<bundle identifier> <date> <time>.log"
+ * Example: com.organization.myapp 2013-12-03 17-14.log
+ *
+ * If you wish to change default filename, you can override following two methods.
+ * - newLogFileName method would be called on new logfile creation.
+ * - isLogFile: method would be called to filter logfiles from all other files in logsDirectory.
+ *   You have to parse given filename and return YES if it is logFile.
+ *
+ * **NOTE**
+ * newLogFileName returns filename. If appropriate file already exists, number would be added
+ * to filename before extension. You have to handle this case in isLogFile: method.
+ *
+ * Example:
+ * - newLogFileName returns "com.organization.myapp 2013-12-03.log",
+ *   file "com.organization.myapp 2013-12-03.log" would be created.
+ * - after some time "com.organization.myapp 2013-12-03.log" is archived
+ * - newLogFileName again returns "com.organization.myapp 2013-12-03.log",
+ *   file "com.organization.myapp 2013-12-03 2.log" would be created.
+ * - after some time "com.organization.myapp 2013-12-03 1.log" is archived
+ * - newLogFileName again returns "com.organization.myapp 2013-12-03.log",
+ *   file "com.organization.myapp 2013-12-03 3.log" would be created.
+**/
+- (NSString *)newLogFileName;
+- (BOOL)isLogFile:(NSString *)fileName;
 
 /* Inherited from DDLogFileManager protocol:
 
@@ -156,11 +184,11 @@
 **/
 @interface DDLogFileFormatterDefault : NSObject <DDLogFormatter>
 {
-	NSDateFormatter *dateFormatter;
+    NSDateFormatter *dateFormatter;
 }
 
 - (id)init;
-- (id)initWithDateFormatter:(NSDateFormatter *)dateFormatter;
+- (instancetype)initWithDateFormatter:(NSDateFormatter *)dateFormatter;
 
 @end
 
@@ -170,19 +198,20 @@
 
 @interface DDFileLogger : DDAbstractLogger <DDLogger>
 {
-	__strong id <DDLogFileManager> logFileManager;
-	
-	DDLogFileInfo *currentLogFileInfo;
-	NSFileHandle *currentLogFileHandle;
-	
-	dispatch_source_t rollingTimer;
-	
-	unsigned long long maximumFileSize;
-	NSTimeInterval rollingFrequency;
+    __strong id <DDLogFileManager> logFileManager;
+    
+    DDLogFileInfo *currentLogFileInfo;
+    NSFileHandle *currentLogFileHandle;
+    
+    dispatch_source_t currentLogFileVnode;
+    dispatch_source_t rollingTimer;
+    
+    unsigned long long maximumFileSize;
+    NSTimeInterval rollingFrequency;
 }
 
 - (id)init;
-- (id)initWithLogFileManager:(id <DDLogFileManager>)logFileManager;
+- (instancetype)initWithLogFileManager:(id <DDLogFileManager>)logFileManager;
 
 /**
  * Log File Rolling:
@@ -228,8 +257,13 @@
 
 
 // You can optionally force the current log file to be rolled with this method.
+// CompletionBlock will be called on main queue.
+
+- (void)rollLogFileWithCompletionBlock:(void (^)())completionBlock;
+
+// Method is deprecated. Use rollLogFileWithCompletionBlock: method instead.
 
-- (void)rollLogFile;
+- (void)rollLogFile __attribute((deprecated));
 
 // Inherited from DDAbstractLogger
 
@@ -258,15 +292,15 @@
 **/
 @interface DDLogFileInfo : NSObject
 {
-	__strong NSString *filePath;
-	__strong NSString *fileName;
-	
-	__strong NSDictionary *fileAttributes;
-	
-	__strong NSDate *creationDate;
-	__strong NSDate *modificationDate;
-	
-	unsigned long long fileSize;
+    __strong NSString *filePath;
+    __strong NSString *fileName;
+    
+    __strong NSDictionary *fileAttributes;
+    
+    __strong NSDate *creationDate;
+    __strong NSDate *modificationDate;
+    
+    unsigned long long fileSize;
 }
 
 @property (strong, nonatomic, readonly) NSString *filePath;
@@ -283,9 +317,9 @@
 
 @property (nonatomic, readwrite) BOOL isArchived;
 
-+ (id)logFileWithPath:(NSString *)filePath;
++ (instancetype)logFileWithPath:(NSString *)filePath;
 
-- (id)initWithFilePath:(NSString *)filePath;
+- (instancetype)initWithFilePath:(NSString *)filePath;
 
 - (void)reset;
 - (void)renameFile:(NSString *)newFileName;
@@ -309,7 +343,8 @@
 // On the simulator we add an attribute by appending a filename extension.
 // 
 // For example:
-// log-ABC123.txt -> log-ABC123.archived.txt
+// "mylog.txt" -> "mylog.archived.txt"
+// "mylog"     -> "mylog.archived"
 
 - (BOOL)hasExtensionAttributeWithName:(NSString *)attrName;
 

data/vendor/Pods/CocoaLumberjack/Lumberjack/DDFileLogger.m

@@ -9,10 +9,10 @@
  * Welcome to Cocoa Lumberjack!
  * 
  * The project page has a wealth of documentation if you have any questions.
- * https://github.com/robbiehanson/CocoaLumberjack
+ * https://github.com/CocoaLumberjack/CocoaLumberjack
  * 
  * If you're new to the project you may wish to read the "Getting Started" wiki.
- * https://github.com/robbiehanson/CocoaLumberjack/wiki/GettingStarted
+ * https://github.com/CocoaLumberjack/CocoaLumberjack/wiki/GettingStarted
 **/
 
 #if ! __has_feature(objc_arc)
@@ -31,7 +31,8 @@
 #define NSLogError(frmt, ...)    do{ if(LOG_LEVEL >= 1) NSLog((frmt), ##__VA_ARGS__); } while(0)
 #define NSLogWarn(frmt, ...)     do{ if(LOG_LEVEL >= 2) NSLog((frmt), ##__VA_ARGS__); } while(0)
 #define NSLogInfo(frmt, ...)     do{ if(LOG_LEVEL >= 3) NSLog((frmt), ##__VA_ARGS__); } while(0)
-#define NSLogVerbose(frmt, ...)  do{ if(LOG_LEVEL >= 4) NSLog((frmt), ##__VA_ARGS__); } while(0)
+#define NSLogDebug(frmt, ...)    do{ if(LOG_LEVEL >= 4) NSLog((frmt), ##__VA_ARGS__); } while(0)
+#define NSLogVerbose(frmt, ...)  do{ if(LOG_LEVEL >= 5) NSLog((frmt), ##__VA_ARGS__); } while(0)
 
 @interface DDLogFileManagerDefault (PrivateAPI)
 
@@ -48,6 +49,10 @@
 
 @end
 
+#if TARGET_OS_IPHONE
+BOOL doesAppRunInBackground(void);
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma mark -
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -58,33 +63,39 @@
 
 - (id)init
 {
-	return [self initWithLogsDirectory:nil];
+    return [self initWithLogsDirectory:nil];
 }
 
-- (id)initWithLogsDirectory:(NSString *)aLogsDirectory
+- (instancetype)initWithLogsDirectory:(NSString *)aLogsDirectory
 {
-	if ((self = [super init]))
-	{
-		maximumNumberOfLogFiles = DEFAULT_LOG_MAX_NUM_LOG_FILES;
-		
-		if (aLogsDirectory)
-			_logsDirectory = [aLogsDirectory copy];
-		else
-			_logsDirectory = [[self defaultLogsDirectory] copy];
-		
-		NSKeyValueObservingOptions kvoOptions = NSKeyValueObservingOptionOld | NSKeyValueObservingOptionNew;
-		
-		[self addObserver:self forKeyPath:@"maximumNumberOfLogFiles" options:kvoOptions context:nil];
-		
-		NSLogVerbose(@"DDFileLogManagerDefault: logsDirectory:\n%@", [self logsDirectory]);
-		NSLogVerbose(@"DDFileLogManagerDefault: sortedLogFileNames:\n%@", [self sortedLogFileNames]);
-	}
-	return self;
+    if ((self = [super init]))
+    {
+        maximumNumberOfLogFiles = DEFAULT_LOG_MAX_NUM_LOG_FILES;
+        
+        if (aLogsDirectory)
+            _logsDirectory = [aLogsDirectory copy];
+        else
+            _logsDirectory = [[self defaultLogsDirectory] copy];
+        
+        NSKeyValueObservingOptions kvoOptions = NSKeyValueObservingOptionOld | NSKeyValueObservingOptionNew;
+        
+        [self addObserver:self forKeyPath:NSStringFromSelector(@selector(maximumNumberOfLogFiles)) options:kvoOptions context:nil];
+        
+        NSLogVerbose(@"DDFileLogManagerDefault: logsDirectory:\n%@", [self logsDirectory]);
+        NSLogVerbose(@"DDFileLogManagerDefault: sortedLogFileNames:\n%@", [self sortedLogFileNames]);
+    }
+    return self;
 }
 
 - (void)dealloc
 {
-	[self removeObserver:self forKeyPath:@"maximumNumberOfLogFiles"];
+    // try-catch because the observer might be removed or never added. In this case, removeObserver throws and exception
+    @try {
+        [self removeObserver:self forKeyPath:NSStringFromSelector(@selector(maximumNumberOfLogFiles))];
+    }
+    @catch (NSException *exception) {
+        
+    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -96,24 +107,24 @@
                         change:(NSDictionary *)change
                        context:(void *)context
 {
-	NSNumber *old = [change objectForKey:NSKeyValueChangeOldKey];
-	NSNumber *new = [change objectForKey:NSKeyValueChangeNewKey];
-	
-	if ([old isEqual:new])
-	{
-		// No change in value - don't bother with any processing.
-		return;
-	}
-	
-	if ([keyPath isEqualToString:@"maximumNumberOfLogFiles"])
-	{
-		NSLogInfo(@"DDFileLogManagerDefault: Responding to configuration change: maximumNumberOfLogFiles");
-		
-		dispatch_async([DDLog loggingQueue], ^{ @autoreleasepool {
-			
-			[self deleteOldLogFiles];
-		}});
-	}
+    NSNumber *old = [change objectForKey:NSKeyValueChangeOldKey];
+    NSNumber *new = [change objectForKey:NSKeyValueChangeNewKey];
+    
+    if ([old isEqual:new])
+    {
+        // No change in value - don't bother with any processing.
+        return;
+    }
+    
+    if ([keyPath isEqualToString:NSStringFromSelector(@selector(maximumNumberOfLogFiles))])
+    {
+        NSLogInfo(@"DDFileLogManagerDefault: Responding to configuration change: maximumNumberOfLogFiles");
+        
+        dispatch_async([DDLog loggingQueue], ^{ @autoreleasepool {
+            
+            [self deleteOldLogFiles];
+        }});
+    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -125,55 +136,55 @@
 **/
 - (void)deleteOldLogFiles
 {
-	NSLogVerbose(@"DDLogFileManagerDefault: deleteOldLogFiles");
-	
-	NSUInteger maxNumLogFiles = self.maximumNumberOfLogFiles;
-	if (maxNumLogFiles == 0)
-	{
-		// Unlimited - don't delete any log files
-		return;
-	}
-	
-	NSArray *sortedLogFileInfos = [self sortedLogFileInfos];
-	
-	// Do we consider the first file?
-	// We are only supposed to be deleting archived files.
-	// In most cases, the first file is likely the log file that is currently being written to.
-	// So in most cases, we do not want to consider this file for deletion.
-	
-	NSUInteger count = [sortedLogFileInfos count];
-	BOOL excludeFirstFile = NO;
-	
-	if (count > 0)
-	{
-		DDLogFileInfo *logFileInfo = [sortedLogFileInfos objectAtIndex:0];
-		
-		if (!logFileInfo.isArchived)
-		{
-			excludeFirstFile = YES;
-		}
-	}
-	
-	NSArray *sortedArchivedLogFileInfos;
-	if (excludeFirstFile)
-	{
-		count--;
-		sortedArchivedLogFileInfos = [sortedLogFileInfos subarrayWithRange:NSMakeRange(1, count)];
-	}
-	else
-	{
-		sortedArchivedLogFileInfos = sortedLogFileInfos;
-	}
-	
-	NSUInteger i;
-	for (i = maxNumLogFiles; i < count; i++)
-	{
-		DDLogFileInfo *logFileInfo = [sortedArchivedLogFileInfos objectAtIndex:i];
-		
-		NSLogInfo(@"DDLogFileManagerDefault: Deleting file: %@", logFileInfo.fileName);
-		
-		[[NSFileManager defaultManager] removeItemAtPath:logFileInfo.filePath error:nil];
-	}
+    NSLogVerbose(@"DDLogFileManagerDefault: deleteOldLogFiles");
+    
+    NSUInteger maxNumLogFiles = self.maximumNumberOfLogFiles;
+    if (maxNumLogFiles == 0)
+    {
+        // Unlimited - don't delete any log files
+        return;
+    }
+    
+    NSArray *sortedLogFileInfos = [self sortedLogFileInfos];
+    
+    // Do we consider the first file?
+    // We are only supposed to be deleting archived files.
+    // In most cases, the first file is likely the log file that is currently being written to.
+    // So in most cases, we do not want to consider this file for deletion.
+    
+    NSUInteger count = [sortedLogFileInfos count];
+    BOOL excludeFirstFile = NO;
+    
+    if (count > 0)
+    {
+        DDLogFileInfo *logFileInfo = [sortedLogFileInfos objectAtIndex:0];
+        
+        if (!logFileInfo.isArchived)
+        {
+            excludeFirstFile = YES;
+        }
+    }
+    
+    NSArray *sortedArchivedLogFileInfos;
+    if (excludeFirstFile)
+    {
+        count--;
+        sortedArchivedLogFileInfos = [sortedLogFileInfos subarrayWithRange:NSMakeRange(1, count)];
+    }
+    else
+    {
+        sortedArchivedLogFileInfos = sortedLogFileInfos;
+    }
+    
+    NSUInteger i;
+    for (i = maxNumLogFiles; i < count; i++)
+    {
+        DDLogFileInfo *logFileInfo = [sortedArchivedLogFileInfos objectAtIndex:i];
+        
+        NSLogInfo(@"DDLogFileManagerDefault: Deleting file: %@", logFileInfo.fileName);
+        
+        [[NSFileManager defaultManager] removeItemAtPath:logFileInfo.filePath error:nil];
+    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -187,64 +198,97 @@
 - (NSString *)defaultLogsDirectory
 {
 #if TARGET_OS_IPHONE
-	NSArray *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
-	NSString *baseDir = ([paths count] > 0) ? [paths objectAtIndex:0] : nil;
-	NSString *logsDirectory = [baseDir stringByAppendingPathComponent:@"Logs"];
+    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
+    NSString *baseDir = ([paths count] > 0) ? [paths objectAtIndex:0] : nil;
+    NSString *logsDirectory = [baseDir stringByAppendingPathComponent:@"Logs"];
     
 #else
-	NSString *appName = [[NSProcessInfo processInfo] processName];
-	NSArray *paths = NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES);
-	NSString *basePath = ([paths count] > 0) ? [paths objectAtIndex:0] : NSTemporaryDirectory();
-	NSString *logsDirectory = [[basePath stringByAppendingPathComponent:@"Logs"] stringByAppendingPathComponent:appName];
+    NSString *appName = [[NSProcessInfo processInfo] processName];
+    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES);
+    NSString *basePath = ([paths count] > 0) ? [paths objectAtIndex:0] : NSTemporaryDirectory();
+    NSString *logsDirectory = [[basePath stringByAppendingPathComponent:@"Logs"] stringByAppendingPathComponent:appName];
 
 #endif
 
-	return logsDirectory;
+    return logsDirectory;
 }
 
 - (NSString *)logsDirectory
 {
-	// We could do this check once, during initalization, and not bother again.
-	// But this way the code continues to work if the directory gets deleted while the code is running.
-	
-	if (![[NSFileManager defaultManager] fileExistsAtPath:_logsDirectory])
-	{
-		NSError *err = nil;
-		if (![[NSFileManager defaultManager] createDirectoryAtPath:_logsDirectory
-		                               withIntermediateDirectories:YES attributes:nil error:&err])
-		{
-			NSLogError(@"DDFileLogManagerDefault: Error creating logsDirectory: %@", err);
-		}
-	}
-	
-	return _logsDirectory;
+    // We could do this check once, during initalization, and not bother again.
+    // But this way the code continues to work if the directory gets deleted while the code is running.
+    
+    if (![[NSFileManager defaultManager] fileExistsAtPath:_logsDirectory])
+    {
+        NSError *err = nil;
+        if (![[NSFileManager defaultManager] createDirectoryAtPath:_logsDirectory
+                                       withIntermediateDirectories:YES attributes:nil error:&err])
+        {
+            NSLogError(@"DDFileLogManagerDefault: Error creating logsDirectory: %@", err);
+        }
+    }
+    
+    return _logsDirectory;
 }
 
+/**
+ * Default log file name is "<bundle identifier> <date> <time>.log".
+ * Example: MobileSafari 2013-12-03 17-14.log
+ *
+ * You can change it by overriding newLogFileName and isLogFile: methods.
+**/
 - (BOOL)isLogFile:(NSString *)fileName
 {
-	// A log file has a name like "log-<uuid>.txt", where <uuid> is a HEX-string of 6 characters.
-	// 
-	// For example: log-DFFE99.txt
-	
-	BOOL hasProperPrefix = [fileName hasPrefix:@"log-"];
-	
-	BOOL hasProperLength = [fileName length] >= 10;
-	
-	
-	if (hasProperPrefix && hasProperLength)
-	{
-		NSCharacterSet *hexSet = [NSCharacterSet characterSetWithCharactersInString:@"0123456789ABCDEF"];
-		
-		NSString *hex = [fileName substringWithRange:NSMakeRange(4, 6)];
-		NSString *nohex = [hex stringByTrimmingCharactersInSet:hexSet];
-		
-		if ([nohex length] == 0)
-		{
-			return YES;
-		}
-	}
-	
-	return NO;
+    NSString *appName = [self applicationName];
+
+    BOOL hasProperPrefix = [fileName hasPrefix:appName];
+    BOOL hasProperSuffix = [fileName hasSuffix:@".log"];
+    BOOL hasProperDate = NO;
+
+    if (hasProperPrefix && hasProperSuffix)
+    {
+        NSUInteger lengthOfMiddle = fileName.length - appName.length - @".log".length;
+
+        // Date string should have at least 16 characters - " 2013-12-03 17-14"
+        if (lengthOfMiddle >= 17)
+        {
+            NSRange range = NSMakeRange(appName.length, lengthOfMiddle);
+
+            NSString *middle = [fileName substringWithRange:range];
+            NSArray *components = [middle componentsSeparatedByString:@" "];
+
+            // When creating logfile if there is existing file with the same name, we append attemp number at the end.
+            // Thats why here we can have three or four components. For details see createNewLogFile method.
+            //
+            // Components:
+            //     "", "2013-12-03", "17-14"
+            // or
+            //     "", "2013-12-03", "17-14", "1"
+            if (components.count == 3 || components.count == 4)
+            {
+                NSString *dateString = [NSString stringWithFormat:@"%@ %@", components[1], components[2]];
+                NSDateFormatter *dateFormatter = [self logFileDateFormatter];
+
+                NSDate *date = [dateFormatter dateFromString:dateString];
+
+                if (date)
+                {
+                    hasProperDate = YES;
+                }
+            }
+        }
+    }
+
+    return (hasProperPrefix && hasProperDate && hasProperSuffix);
+}
+
+- (NSDateFormatter *)logFileDateFormatter
+{
+    NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
+    [dateFormatter setDateFormat:@"yyyy'-'MM'-'dd' 'HH'-'mm'"];
+    [dateFormatter setTimeZone:[NSTimeZone timeZoneForSecondsFromGMT:0]];
+
+    return dateFormatter;
 }
 
 /**
@@ -253,24 +297,35 @@
 **/
 - (NSArray *)unsortedLogFilePaths
 {
-	NSString *logsDirectory = [self logsDirectory];
-	NSArray *fileNames = [[NSFileManager defaultManager] contentsOfDirectoryAtPath:logsDirectory error:nil];
-	
-	NSMutableArray *unsortedLogFilePaths = [NSMutableArray arrayWithCapacity:[fileNames count]];
-	
-	for (NSString *fileName in fileNames)
-	{
-		// Filter out any files that aren't log files. (Just for extra safety)
-		
-		if ([self isLogFile:fileName])
-		{
-			NSString *filePath = [logsDirectory stringByAppendingPathComponent:fileName];
-			
-			[unsortedLogFilePaths addObject:filePath];
-		}
-	}
-	
-	return unsortedLogFilePaths;
+    NSString *logsDirectory = [self logsDirectory];
+    NSArray *fileNames = [[NSFileManager defaultManager] contentsOfDirectoryAtPath:logsDirectory error:nil];
+    
+    NSMutableArray *unsortedLogFilePaths = [NSMutableArray arrayWithCapacity:[fileNames count]];
+    
+    for (NSString *fileName in fileNames)
+    {
+        // Filter out any files that aren't log files. (Just for extra safety)
+        
+    #if TARGET_IPHONE_SIMULATOR
+        // In case of iPhone simulator there can be 'archived' extension. isLogFile:
+        // method knows nothing about it. Thus removing it for this method.
+        //
+        // See full explanation in the header file.
+        NSString *theFileName = [fileName stringByReplacingOccurrencesOfString:@".archived"
+                                                                    withString:@""];
+
+        if ([self isLogFile:theFileName])
+    #else
+        if ([self isLogFile:fileName])
+    #endif
+        {
+            NSString *filePath = [logsDirectory stringByAppendingPathComponent:fileName];
+            
+            [unsortedLogFilePaths addObject:filePath];
+        }
+    }
+    
+    return unsortedLogFilePaths;
 }
 
 /**
@@ -279,16 +334,16 @@
 **/
 - (NSArray *)unsortedLogFileNames
 {
-	NSArray *unsortedLogFilePaths = [self unsortedLogFilePaths];
-	
-	NSMutableArray *unsortedLogFileNames = [NSMutableArray arrayWithCapacity:[unsortedLogFilePaths count]];
-	
-	for (NSString *filePath in unsortedLogFilePaths)
-	{
-		[unsortedLogFileNames addObject:[filePath lastPathComponent]];
-	}
-	
-	return unsortedLogFileNames;
+    NSArray *unsortedLogFilePaths = [self unsortedLogFilePaths];
+    
+    NSMutableArray *unsortedLogFileNames = [NSMutableArray arrayWithCapacity:[unsortedLogFilePaths count]];
+    
+    for (NSString *filePath in unsortedLogFilePaths)
+    {
+        [unsortedLogFileNames addObject:[filePath lastPathComponent]];
+    }
+    
+    return unsortedLogFileNames;
 }
 
 /**
@@ -298,66 +353,66 @@
 **/
 - (NSArray *)unsortedLogFileInfos
 {
-	NSArray *unsortedLogFilePaths = [self unsortedLogFilePaths];
-	
-	NSMutableArray *unsortedLogFileInfos = [NSMutableArray arrayWithCapacity:[unsortedLogFilePaths count]];
-	
-	for (NSString *filePath in unsortedLogFilePaths)
-	{
-		DDLogFileInfo *logFileInfo = [[DDLogFileInfo alloc] initWithFilePath:filePath];
-		
-		[unsortedLogFileInfos addObject:logFileInfo];
-	}
-	
-	return unsortedLogFileInfos;
+    NSArray *unsortedLogFilePaths = [self unsortedLogFilePaths];
+    
+    NSMutableArray *unsortedLogFileInfos = [NSMutableArray arrayWithCapacity:[unsortedLogFilePaths count]];
+    
+    for (NSString *filePath in unsortedLogFilePaths)
+    {
+        DDLogFileInfo *logFileInfo = [[DDLogFileInfo alloc] initWithFilePath:filePath];
+        
+        [unsortedLogFileInfos addObject:logFileInfo];
+    }
+    
+    return unsortedLogFileInfos;
 }
 
 /**
  * Just like the unsortedLogFilePaths method, but sorts the array.
- * The items in the array are sorted by modification date.
- * The first item in the array will be the most recently modified log file.
+ * The items in the array are sorted by creation date.
+ * The first item in the array will be the most recently created log file.
 **/
 - (NSArray *)sortedLogFilePaths
 {
-	NSArray *sortedLogFileInfos = [self sortedLogFileInfos];
-	
-	NSMutableArray *sortedLogFilePaths = [NSMutableArray arrayWithCapacity:[sortedLogFileInfos count]];
-	
-	for (DDLogFileInfo *logFileInfo in sortedLogFileInfos)
-	{
-		[sortedLogFilePaths addObject:[logFileInfo filePath]];
-	}
-	
-	return sortedLogFilePaths;
+    NSArray *sortedLogFileInfos = [self sortedLogFileInfos];
+    
+    NSMutableArray *sortedLogFilePaths = [NSMutableArray arrayWithCapacity:[sortedLogFileInfos count]];
+    
+    for (DDLogFileInfo *logFileInfo in sortedLogFileInfos)
+    {
+        [sortedLogFilePaths addObject:[logFileInfo filePath]];
+    }
+    
+    return sortedLogFilePaths;
 }
 
 /**
  * Just like the unsortedLogFileNames method, but sorts the array.
- * The items in the array are sorted by modification date.
- * The first item in the array will be the most recently modified log file.
+ * The items in the array are sorted by creation date.
+ * The first item in the array will be the most recently created log file.
 **/
 - (NSArray *)sortedLogFileNames
 {
-	NSArray *sortedLogFileInfos = [self sortedLogFileInfos];
-	
-	NSMutableArray *sortedLogFileNames = [NSMutableArray arrayWithCapacity:[sortedLogFileInfos count]];
-	
-	for (DDLogFileInfo *logFileInfo in sortedLogFileInfos)
-	{
-		[sortedLogFileNames addObject:[logFileInfo fileName]];
-	}
-	
-	return sortedLogFileNames;
+    NSArray *sortedLogFileInfos = [self sortedLogFileInfos];
+    
+    NSMutableArray *sortedLogFileNames = [NSMutableArray arrayWithCapacity:[sortedLogFileInfos count]];
+    
+    for (DDLogFileInfo *logFileInfo in sortedLogFileInfos)
+    {
+        [sortedLogFileNames addObject:[logFileInfo fileName]];
+    }
+    
+    return sortedLogFileNames;
 }
 
 /**
  * Just like the unsortedLogFileInfos method, but sorts the array.
- * The items in the array are sorted by modification date.
- * The first item in the array will be the most recently modified log file.
+ * The items in the array are sorted by creation date.
+ * The first item in the array will be the most recently created log file.
 **/
 - (NSArray *)sortedLogFileInfos
 {
-	return [[self unsortedLogFileInfos] sortedArrayUsingSelector:@selector(reverseCompareByCreationDate:)];
+    return [[self unsortedLogFileInfos] sortedArrayUsingSelector:@selector(reverseCompareByCreationDate:)];
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -365,20 +420,19 @@
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
- * Generates a short UUID suitable for use in the log file's name.
- * The result will have six characters, all in the hexadecimal set [0123456789ABCDEF].
+ * Generates log file name with default format "<bundle identifier> <date> <time>.log"
+ * Example: MobileSafari 2013-12-03 17-14.log
+ *
+ * You can change it by overriding newLogFileName and isLogFile: methods.
 **/
-- (NSString *)generateShortUUID
+- (NSString *)newLogFileName
 {
-	CFUUIDRef uuid = CFUUIDCreate(NULL);
-	
-	CFStringRef fullStr = CFUUIDCreateString(NULL, uuid);
-	NSString *result = (__bridge_transfer NSString *)CFStringCreateWithSubstring(NULL, fullStr, CFRangeMake(0, 6));
-	
-	CFRelease(fullStr);
-	CFRelease(uuid);
-	
-	return result;
+    NSString *appName = [self applicationName];
+
+    NSDateFormatter *dateFormatter = [self logFileDateFormatter];
+    NSString *formattedDate = [dateFormatter stringFromDate:[NSDate date]];
+
+    return [NSString stringWithFormat:@"%@ %@.log", appName, formattedDate];
 }
 
 /**
@@ -386,28 +440,82 @@
 **/
 - (NSString *)createNewLogFile
 {
-	// Generate a random log file name, and create the file (if there isn't a collision)
-	
-	NSString *logsDirectory = [self logsDirectory];
-	do
-	{
-		NSString *fileName = [NSString stringWithFormat:@"log-%@.txt", [self generateShortUUID]];
-		
-		NSString *filePath = [logsDirectory stringByAppendingPathComponent:fileName];
-		
-		if (![[NSFileManager defaultManager] fileExistsAtPath:filePath])
-		{
-			NSLogVerbose(@"DDLogFileManagerDefault: Creating new log file: %@", fileName);
-			
-			[[NSFileManager defaultManager] createFileAtPath:filePath contents:nil attributes:nil];
-			
-			// Since we just created a new log file, we may need to delete some old log files
-			[self deleteOldLogFiles];
-			
-			return filePath;
-		}
-		
-	} while(YES);
+    NSString *fileName = [self newLogFileName];
+    NSString *logsDirectory = [self logsDirectory];
+
+    NSUInteger attempt = 1;
+    do
+    {
+        NSString *actualFileName = fileName;
+
+        if (attempt > 1) {
+            NSString *extension = [actualFileName pathExtension];
+
+            actualFileName = [actualFileName stringByDeletingPathExtension];
+            actualFileName = [actualFileName stringByAppendingFormat:@" %lu", (unsigned long)attempt];
+            if (extension.length) {
+                actualFileName = [actualFileName stringByAppendingPathExtension:extension];
+            }
+        }
+
+        NSString *filePath = [logsDirectory stringByAppendingPathComponent:actualFileName];
+
+        if (![[NSFileManager defaultManager] fileExistsAtPath:filePath])
+        {
+            NSLogVerbose(@"DDLogFileManagerDefault: Creating new log file: %@", actualFileName);
+
+            NSDictionary *attributes = nil;
+
+        #if TARGET_OS_IPHONE
+             // When creating log file on iOS we're setting NSFileProtectionKey attribute to NSFileProtectionCompleteUnlessOpen.
+             // 
+             // But in case if app is able to launch from background we need to have an ability to open log file any time we
+             // want (even if device is locked). Thats why that attribute have to be changed to
+             // NSFileProtectionCompleteUntilFirstUserAuthentication.
+
+            NSString *key = doesAppRunInBackground() ?
+                NSFileProtectionCompleteUntilFirstUserAuthentication : NSFileProtectionCompleteUnlessOpen;
+
+            attributes = @{ NSFileProtectionKey : key };
+        #endif
+            
+            [[NSFileManager defaultManager] createFileAtPath:filePath contents:nil attributes:attributes];
+            
+            // Since we just created a new log file, we may need to delete some old log files
+            [self deleteOldLogFiles];
+            
+            return filePath;
+        } else {
+            attempt++;
+        }
+        
+    } while(YES);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma mark Utility
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+- (NSString *)applicationName
+{
+    static NSString *_appName;
+    static dispatch_once_t onceToken;
+
+    dispatch_once(&onceToken, ^{
+        _appName = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"CFBundleIdentifier"];
+
+        if (! _appName)
+        {
+            _appName = [[NSProcessInfo processInfo] processName];
+        }
+
+        if (! _appName)
+        {
+            _appName = @"";
+        }
+    });
+
+    return _appName;
 }
 
 @end
@@ -420,32 +528,32 @@
 
 - (id)init
 {
-	return [self initWithDateFormatter:nil];
+    return [self initWithDateFormatter:nil];
 }
 
-- (id)initWithDateFormatter:(NSDateFormatter *)aDateFormatter
+- (instancetype)initWithDateFormatter:(NSDateFormatter *)aDateFormatter
 {
-	if ((self = [super init]))
-	{
-		if (aDateFormatter)
-		{
-			dateFormatter = aDateFormatter;
-		}
-		else
-		{
-			dateFormatter = [[NSDateFormatter alloc] init];
-			[dateFormatter setFormatterBehavior:NSDateFormatterBehavior10_4]; // 10.4+ style
-			[dateFormatter setDateFormat:@"yyyy/MM/dd HH:mm:ss:SSS"];
-		}
-	}
-	return self;
+    if ((self = [super init]))
+    {
+        if (aDateFormatter)
+        {
+            dateFormatter = aDateFormatter;
+        }
+        else
+        {
+            dateFormatter = [[NSDateFormatter alloc] init];
+            [dateFormatter setFormatterBehavior:NSDateFormatterBehavior10_4]; // 10.4+ style
+            [dateFormatter setDateFormat:@"yyyy/MM/dd HH:mm:ss:SSS"];
+        }
+    }
+    return self;
 }
 
 - (NSString *)formatLogMessage:(DDLogMessage *)logMessage
 {
-	NSString *dateAndTime = [dateFormatter stringFromDate:(logMessage->timestamp)];
-	
-	return [NSString stringWithFormat:@"%@  %@", dateAndTime, logMessage->logMsg];
+    NSString *dateAndTime = [dateFormatter stringFromDate:(logMessage->timestamp)];
+    
+    return [NSString stringWithFormat:@"%@  %@", dateAndTime, logMessage->logMsg];
 }
 
 @end
@@ -458,35 +566,40 @@
 
 - (id)init
 {
-	DDLogFileManagerDefault *defaultLogFileManager = [[DDLogFileManagerDefault alloc] init];
-	
-	return [self initWithLogFileManager:defaultLogFileManager];
+    DDLogFileManagerDefault *defaultLogFileManager = [[DDLogFileManagerDefault alloc] init];
+    
+    return [self initWithLogFileManager:defaultLogFileManager];
 }
 
-- (id)initWithLogFileManager:(id <DDLogFileManager>)aLogFileManager
+- (instancetype)initWithLogFileManager:(id <DDLogFileManager>)aLogFileManager
 {
-	if ((self = [super init]))
-	{
-		maximumFileSize = DEFAULT_LOG_MAX_FILE_SIZE;
-		rollingFrequency = DEFAULT_LOG_ROLLING_FREQUENCY;
-		
-		logFileManager = aLogFileManager;
-		
-		formatter = [[DDLogFileFormatterDefault alloc] init];
-	}
-	return self;
+    if ((self = [super init]))
+    {
+        maximumFileSize = DEFAULT_LOG_MAX_FILE_SIZE;
+        rollingFrequency = DEFAULT_LOG_ROLLING_FREQUENCY;
+        
+        logFileManager = aLogFileManager;
+        
+        formatter = [[DDLogFileFormatterDefault alloc] init];
+    }
+    return self;
 }
 
 - (void)dealloc
 {
-	[currentLogFileHandle synchronizeFile];
-	[currentLogFileHandle closeFile];
-	
-	if (rollingTimer)
-	{
-		dispatch_source_cancel(rollingTimer);
-		rollingTimer = NULL;
-	}
+    [currentLogFileHandle synchronizeFile];
+    [currentLogFileHandle closeFile];
+
+    if (currentLogFileVnode) {
+        dispatch_source_cancel(currentLogFileVnode);
+        currentLogFileVnode = NULL;
+    }
+
+    if (rollingTimer)
+    {
+        dispatch_source_cancel(rollingTimer);
+        rollingTimer = NULL;
+    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -497,119 +610,119 @@
 
 - (unsigned long long)maximumFileSize
 {
-	__block unsigned long long result;
-	
-	dispatch_block_t block = ^{
-		result = maximumFileSize;
-	};
-	
-	// The design of this method is taken from the DDAbstractLogger implementation.
-	// For extensive documentation please refer to the DDAbstractLogger implementation.
-	
-	// Note: The internal implementation MUST access the maximumFileSize variable directly,
-	// This method is designed explicitly for external access.
-	//
-	// Using "self." syntax to go through this method will cause immediate deadlock.
-	// This is the intended result. Fix it by accessing the ivar directly.
-	// Great strides have been take to ensure this is safe to do. Plus it's MUCH faster.
-	
-	NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
-	NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
-	
-	dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
-	
-	dispatch_sync(globalLoggingQueue, ^{
-		dispatch_sync(loggerQueue, block);
-	});
-	
-	return result;
+    __block unsigned long long result;
+    
+    dispatch_block_t block = ^{
+        result = maximumFileSize;
+    };
+    
+    // The design of this method is taken from the DDAbstractLogger implementation.
+    // For extensive documentation please refer to the DDAbstractLogger implementation.
+    
+    // Note: The internal implementation MUST access the maximumFileSize variable directly,
+    // This method is designed explicitly for external access.
+    //
+    // Using "self." syntax to go through this method will cause immediate deadlock.
+    // This is the intended result. Fix it by accessing the ivar directly.
+    // Great strides have been take to ensure this is safe to do. Plus it's MUCH faster.
+    
+    NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
+    NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
+    
+    dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
+    
+    dispatch_sync(globalLoggingQueue, ^{
+        dispatch_sync(loggerQueue, block);
+    });
+    
+    return result;
 }
 
 - (void)setMaximumFileSize:(unsigned long long)newMaximumFileSize
 {
-	dispatch_block_t block = ^{ @autoreleasepool {
-		
-		maximumFileSize = newMaximumFileSize;
-		[self maybeRollLogFileDueToSize];
-		
-	}};
-	
-	// The design of this method is taken from the DDAbstractLogger implementation.
-	// For extensive documentation please refer to the DDAbstractLogger implementation.
-	
-	// Note: The internal implementation MUST access the maximumFileSize variable directly,
-	// This method is designed explicitly for external access.
-	//
-	// Using "self." syntax to go through this method will cause immediate deadlock.
-	// This is the intended result. Fix it by accessing the ivar directly.
-	// Great strides have been take to ensure this is safe to do. Plus it's MUCH faster.
-	
-	NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
-	NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
-	
-	dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
-	
-	dispatch_async(globalLoggingQueue, ^{
-		dispatch_async(loggerQueue, block);
-	});
+    dispatch_block_t block = ^{ @autoreleasepool {
+        
+        maximumFileSize = newMaximumFileSize;
+        [self maybeRollLogFileDueToSize];
+        
+    }};
+    
+    // The design of this method is taken from the DDAbstractLogger implementation.
+    // For extensive documentation please refer to the DDAbstractLogger implementation.
+    
+    // Note: The internal implementation MUST access the maximumFileSize variable directly,
+    // This method is designed explicitly for external access.
+    //
+    // Using "self." syntax to go through this method will cause immediate deadlock.
+    // This is the intended result. Fix it by accessing the ivar directly.
+    // Great strides have been take to ensure this is safe to do. Plus it's MUCH faster.
+    
+    NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
+    NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
+    
+    dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
+    
+    dispatch_async(globalLoggingQueue, ^{
+        dispatch_async(loggerQueue, block);
+    });
 }
 
 - (NSTimeInterval)rollingFrequency
 {
-	__block NSTimeInterval result;
-	
-	dispatch_block_t block = ^{
-		result = rollingFrequency;
-	};
-	
-	// The design of this method is taken from the DDAbstractLogger implementation.
-	// For extensive documentation please refer to the DDAbstractLogger implementation.
-	
-	// Note: The internal implementation should access the rollingFrequency variable directly,
-	// This method is designed explicitly for external access.
-	//
-	// Using "self." syntax to go through this method will cause immediate deadlock.
-	// This is the intended result. Fix it by accessing the ivar directly.
-	// Great strides have been take to ensure this is safe to do. Plus it's MUCH faster.
-	
-	NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
-	NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
-	
-	dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
-	
-	dispatch_sync(globalLoggingQueue, ^{
-		dispatch_sync(loggerQueue, block);
-	});
-	
-	return result;
+    __block NSTimeInterval result;
+    
+    dispatch_block_t block = ^{
+        result = rollingFrequency;
+    };
+    
+    // The design of this method is taken from the DDAbstractLogger implementation.
+    // For extensive documentation please refer to the DDAbstractLogger implementation.
+    
+    // Note: The internal implementation should access the rollingFrequency variable directly,
+    // This method is designed explicitly for external access.
+    //
+    // Using "self." syntax to go through this method will cause immediate deadlock.
+    // This is the intended result. Fix it by accessing the ivar directly.
+    // Great strides have been take to ensure this is safe to do. Plus it's MUCH faster.
+    
+    NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
+    NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
+    
+    dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
+    
+    dispatch_sync(globalLoggingQueue, ^{
+        dispatch_sync(loggerQueue, block);
+    });
+    
+    return result;
 }
 
 - (void)setRollingFrequency:(NSTimeInterval)newRollingFrequency
 {
-	dispatch_block_t block = ^{ @autoreleasepool {
-		
-		rollingFrequency = newRollingFrequency;
-		[self maybeRollLogFileDueToAge];
-	}};
-	
-	// The design of this method is taken from the DDAbstractLogger implementation.
-	// For extensive documentation please refer to the DDAbstractLogger implementation.
-	
-	// Note: The internal implementation should access the rollingFrequency variable directly,
-	// This method is designed explicitly for external access.
-	//
-	// Using "self." syntax to go through this method will cause immediate deadlock.
-	// This is the intended result. Fix it by accessing the ivar directly.
-	// Great strides have been take to ensure this is safe to do. Plus it's MUCH faster.
-	
-	NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
-	NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
-	
-	dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
-	
-	dispatch_async(globalLoggingQueue, ^{
-		dispatch_async(loggerQueue, block);
-	});
+    dispatch_block_t block = ^{ @autoreleasepool {
+        
+        rollingFrequency = newRollingFrequency;
+        [self maybeRollLogFileDueToAge];
+    }};
+    
+    // The design of this method is taken from the DDAbstractLogger implementation.
+    // For extensive documentation please refer to the DDAbstractLogger implementation.
+    
+    // Note: The internal implementation should access the rollingFrequency variable directly,
+    // This method is designed explicitly for external access.
+    //
+    // Using "self." syntax to go through this method will cause immediate deadlock.
+    // This is the intended result. Fix it by accessing the ivar directly.
+    // Great strides have been take to ensure this is safe to do. Plus it's MUCH faster.
+    
+    NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
+    NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
+    
+    dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
+    
+    dispatch_async(globalLoggingQueue, ^{
+        dispatch_async(loggerQueue, block);
+    });
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -618,139 +731,157 @@
 
 - (void)scheduleTimerToRollLogFileDueToAge
 {
-	if (rollingTimer)
-	{
-		dispatch_source_cancel(rollingTimer);
-		rollingTimer = NULL;
-	}
-	
-	if (currentLogFileInfo == nil || rollingFrequency <= 0.0)
-	{
-		return;
-	}
-	
-	NSDate *logFileCreationDate = [currentLogFileInfo creationDate];
-	
-	NSTimeInterval ti = [logFileCreationDate timeIntervalSinceReferenceDate];
-	ti += rollingFrequency;
-	
-	NSDate *logFileRollingDate = [NSDate dateWithTimeIntervalSinceReferenceDate:ti];
-	
-	NSLogVerbose(@"DDFileLogger: scheduleTimerToRollLogFileDueToAge");
-	
-	NSLogVerbose(@"DDFileLogger: logFileCreationDate: %@", logFileCreationDate);
-	NSLogVerbose(@"DDFileLogger: logFileRollingDate : %@", logFileRollingDate);
-	
-	rollingTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, loggerQueue);
-	
-	dispatch_source_set_event_handler(rollingTimer, ^{ @autoreleasepool {
-		
-		[self maybeRollLogFileDueToAge];
-		
-	}});
-	
-	#if !OS_OBJECT_USE_OBJC
-	dispatch_source_t theRollingTimer = rollingTimer;
-	dispatch_source_set_cancel_handler(rollingTimer, ^{
-		dispatch_release(theRollingTimer);
-	});
-	#endif
-	
-	uint64_t delay = (uint64_t)([logFileRollingDate timeIntervalSinceNow] * NSEC_PER_SEC);
-	dispatch_time_t fireTime = dispatch_time(DISPATCH_TIME_NOW, delay);
-	
-	dispatch_source_set_timer(rollingTimer, fireTime, DISPATCH_TIME_FOREVER, 1.0);
-	dispatch_resume(rollingTimer);
+    if (rollingTimer)
+    {
+        dispatch_source_cancel(rollingTimer);
+        rollingTimer = NULL;
+    }
+    
+    if (currentLogFileInfo == nil || rollingFrequency <= 0.0)
+    {
+        return;
+    }
+    
+    NSDate *logFileCreationDate = [currentLogFileInfo creationDate];
+    
+    NSTimeInterval ti = [logFileCreationDate timeIntervalSinceReferenceDate];
+    ti += rollingFrequency;
+    
+    NSDate *logFileRollingDate = [NSDate dateWithTimeIntervalSinceReferenceDate:ti];
+    
+    NSLogVerbose(@"DDFileLogger: scheduleTimerToRollLogFileDueToAge");
+    
+    NSLogVerbose(@"DDFileLogger: logFileCreationDate: %@", logFileCreationDate);
+    NSLogVerbose(@"DDFileLogger: logFileRollingDate : %@", logFileRollingDate);
+    
+    rollingTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, loggerQueue);
+    
+    dispatch_source_set_event_handler(rollingTimer, ^{ @autoreleasepool {
+        
+        [self maybeRollLogFileDueToAge];
+        
+    }});
+    
+    #if !OS_OBJECT_USE_OBJC
+    dispatch_source_t theRollingTimer = rollingTimer;
+    dispatch_source_set_cancel_handler(rollingTimer, ^{
+        dispatch_release(theRollingTimer);
+    });
+    #endif
+    
+    uint64_t delay = (uint64_t)([logFileRollingDate timeIntervalSinceNow] * NSEC_PER_SEC);
+    dispatch_time_t fireTime = dispatch_time(DISPATCH_TIME_NOW, delay);
+    
+    dispatch_source_set_timer(rollingTimer, fireTime, DISPATCH_TIME_FOREVER, 1.0);
+    dispatch_resume(rollingTimer);
 }
 
+
 - (void)rollLogFile
 {
-	// This method is public.
-	// We need to execute the rolling on our logging thread/queue.
-	
-	dispatch_block_t block = ^{ @autoreleasepool {
-		
-		[self rollLogFileNow];
-	}};
-	
-	// The design of this method is taken from the DDAbstractLogger implementation.
-	// For extensive documentation please refer to the DDAbstractLogger implementation.
-	
-	if ([self isOnInternalLoggerQueue])
-	{
-		block();
-	}
-	else
-	{
-		dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
-		NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
-		
-		dispatch_async(globalLoggingQueue, ^{
-			dispatch_async(loggerQueue, block);
-		});
-	}
+    [self rollLogFileWithCompletionBlock:nil];
+}
+
+- (void)rollLogFileWithCompletionBlock:(void (^)())completionBlock
+{
+    // This method is public.
+    // We need to execute the rolling on our logging thread/queue.
+    
+    dispatch_block_t block = ^{ @autoreleasepool {
+        
+        [self rollLogFileNow];
+
+        if (completionBlock)
+        {
+            dispatch_async(dispatch_get_main_queue(), ^{
+                completionBlock();
+            });
+        }
+    }};
+    
+    // The design of this method is taken from the DDAbstractLogger implementation.
+    // For extensive documentation please refer to the DDAbstractLogger implementation.
+    
+    if ([self isOnInternalLoggerQueue])
+    {
+        block();
+    }
+    else
+    {
+        dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
+        NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
+        
+        dispatch_async(globalLoggingQueue, ^{
+            dispatch_async(loggerQueue, block);
+        });
+    }
 }
 
 - (void)rollLogFileNow
 {
-	NSLogVerbose(@"DDFileLogger: rollLogFileNow");
-	
-	
-	if (currentLogFileHandle == nil) return;
-	
-	[currentLogFileHandle synchronizeFile];
-	[currentLogFileHandle closeFile];
-	currentLogFileHandle = nil;
-	
-	currentLogFileInfo.isArchived = YES;
-	
-	if ([logFileManager respondsToSelector:@selector(didRollAndArchiveLogFile:)])
-	{
-		[logFileManager didRollAndArchiveLogFile:(currentLogFileInfo.filePath)];
-	}
-	
-	currentLogFileInfo = nil;
-	
-	if (rollingTimer)
-	{
-		dispatch_source_cancel(rollingTimer);
-		rollingTimer = NULL;
-	}
+    NSLogVerbose(@"DDFileLogger: rollLogFileNow");
+    
+    
+    if (currentLogFileHandle == nil) return;
+    
+    [currentLogFileHandle synchronizeFile];
+    [currentLogFileHandle closeFile];
+    currentLogFileHandle = nil;
+    
+    currentLogFileInfo.isArchived = YES;
+    
+    if ([logFileManager respondsToSelector:@selector(didRollAndArchiveLogFile:)])
+    {
+        [logFileManager didRollAndArchiveLogFile:(currentLogFileInfo.filePath)];
+    }
+    
+    currentLogFileInfo = nil;
+    
+    if (currentLogFileVnode) {
+        dispatch_source_cancel(currentLogFileVnode);
+        currentLogFileVnode = NULL;
+    }
+
+    if (rollingTimer)
+    {
+        dispatch_source_cancel(rollingTimer);
+        rollingTimer = NULL;
+    }
 }
 
 - (void)maybeRollLogFileDueToAge
 {
-	if (rollingFrequency > 0.0 && currentLogFileInfo.age >= rollingFrequency)
-	{
-		NSLogVerbose(@"DDFileLogger: Rolling log file due to age...");
-		
-		[self rollLogFileNow];
-	}
-	else
-	{
-		[self scheduleTimerToRollLogFileDueToAge];
-	}
+    if (rollingFrequency > 0.0 && currentLogFileInfo.age >= rollingFrequency)
+    {
+        NSLogVerbose(@"DDFileLogger: Rolling log file due to age...");
+        
+        [self rollLogFileNow];
+    }
+    else
+    {
+        [self scheduleTimerToRollLogFileDueToAge];
+    }
 }
 
 - (void)maybeRollLogFileDueToSize
 {
-	// This method is called from logMessage.
-	// Keep it FAST.
-	
-	// Note: Use direct access to maximumFileSize variable.
-	// We specifically wrote our own getter/setter method to allow us to do this (for performance reasons).
-	
-	if (maximumFileSize > 0)
-	{
-		unsigned long long fileSize = [currentLogFileHandle offsetInFile];
-		
-		if (fileSize >= maximumFileSize)
-		{
-			NSLogVerbose(@"DDFileLogger: Rolling log file due to size (%qu)...", fileSize);
-			
-			[self rollLogFileNow];
-		}
-	}
+    // This method is called from logMessage.
+    // Keep it FAST.
+    
+    // Note: Use direct access to maximumFileSize variable.
+    // We specifically wrote our own getter/setter method to allow us to do this (for performance reasons).
+    
+    if (maximumFileSize > 0)
+    {
+        unsigned long long fileSize = [currentLogFileHandle offsetInFile];
+        
+        if (fileSize >= maximumFileSize)
+        {
+            NSLogVerbose(@"DDFileLogger: Rolling log file due to size (%qu)...", fileSize);
+            
+            [self rollLogFileNow];
+        }
+    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -766,120 +897,175 @@
 **/
 - (DDLogFileInfo *)currentLogFileInfo
 {
-	if (currentLogFileInfo == nil)
-	{
-		NSArray *sortedLogFileInfos = [logFileManager sortedLogFileInfos];
-		
-		if ([sortedLogFileInfos count] > 0)
-		{
-			DDLogFileInfo *mostRecentLogFileInfo = [sortedLogFileInfos objectAtIndex:0];
-			
-			BOOL useExistingLogFile = YES;
-			BOOL shouldArchiveMostRecent = NO;
-			
-			if (mostRecentLogFileInfo.isArchived)
-			{
-				useExistingLogFile = NO;
-				shouldArchiveMostRecent = NO;
-			}
-			else if (maximumFileSize > 0 && mostRecentLogFileInfo.fileSize >= maximumFileSize)
-			{
-				useExistingLogFile = NO;
-				shouldArchiveMostRecent = YES;
-			}
-			else if (rollingFrequency > 0.0 && mostRecentLogFileInfo.age >= rollingFrequency)
-			{
-				useExistingLogFile = NO;
-				shouldArchiveMostRecent = YES;
-			}
-			
-			if (useExistingLogFile)
-			{
-				NSLogVerbose(@"DDFileLogger: Resuming logging with file %@", mostRecentLogFileInfo.fileName);
-				
-				currentLogFileInfo = mostRecentLogFileInfo;
-			}
-			else
-			{
-				if (shouldArchiveMostRecent)
-				{
-					mostRecentLogFileInfo.isArchived = YES;
-					
-					if ([logFileManager respondsToSelector:@selector(didArchiveLogFile:)])
-					{
-						[logFileManager didArchiveLogFile:(mostRecentLogFileInfo.filePath)];
-					}
-				}
-			}
-		}
-		
-		if (currentLogFileInfo == nil)
-		{
-			NSString *currentLogFilePath = [logFileManager createNewLogFile];
-			
-			currentLogFileInfo = [[DDLogFileInfo alloc] initWithFilePath:currentLogFilePath];
-		}
-	}
-	
-	return currentLogFileInfo;
+    if (currentLogFileInfo == nil)
+    {
+        NSArray *sortedLogFileInfos = [logFileManager sortedLogFileInfos];
+        
+        if ([sortedLogFileInfos count] > 0)
+        {
+            DDLogFileInfo *mostRecentLogFileInfo = [sortedLogFileInfos objectAtIndex:0];
+            
+            BOOL useExistingLogFile = YES;
+            BOOL shouldArchiveMostRecent = NO;
+            
+            if (mostRecentLogFileInfo.isArchived)
+            {
+                useExistingLogFile = NO;
+                shouldArchiveMostRecent = NO;
+            }
+            else if (maximumFileSize > 0 && mostRecentLogFileInfo.fileSize >= maximumFileSize)
+            {
+                useExistingLogFile = NO;
+                shouldArchiveMostRecent = YES;
+            }
+            else if (rollingFrequency > 0.0 && mostRecentLogFileInfo.age >= rollingFrequency)
+            {
+                useExistingLogFile = NO;
+                shouldArchiveMostRecent = YES;
+            }
+
+
+        #if TARGET_OS_IPHONE
+            // When creating log file on iOS we're setting NSFileProtectionKey attribute to NSFileProtectionCompleteUnlessOpen.
+            // 
+            // But in case if app is able to launch from background we need to have an ability to open log file any time we
+            // want (even if device is locked). Thats why that attribute have to be changed to
+            // NSFileProtectionCompleteUntilFirstUserAuthentication.
+            //
+            // If previous log was created when app wasn't running in background, but now it is - we archive it and create
+            // a new one.
+
+            if (useExistingLogFile && doesAppRunInBackground()) {
+                NSString *key = mostRecentLogFileInfo.fileAttributes[NSFileProtectionKey];
+
+                if (! [key isEqualToString:NSFileProtectionCompleteUntilFirstUserAuthentication]) {
+                    useExistingLogFile = NO;
+                    shouldArchiveMostRecent = YES;
+                }
+            }
+        #endif
+            
+            if (useExistingLogFile)
+            {
+                NSLogVerbose(@"DDFileLogger: Resuming logging with file %@", mostRecentLogFileInfo.fileName);
+                
+                currentLogFileInfo = mostRecentLogFileInfo;
+            }
+            else
+            {
+                if (shouldArchiveMostRecent)
+                {
+                    mostRecentLogFileInfo.isArchived = YES;
+                    
+                    if ([logFileManager respondsToSelector:@selector(didArchiveLogFile:)])
+                    {
+                        [logFileManager didArchiveLogFile:(mostRecentLogFileInfo.filePath)];
+                    }
+                }
+            }
+        }
+        
+        if (currentLogFileInfo == nil)
+        {
+            NSString *currentLogFilePath = [logFileManager createNewLogFile];
+            
+            currentLogFileInfo = [[DDLogFileInfo alloc] initWithFilePath:currentLogFilePath];
+        }
+    }
+    
+    return currentLogFileInfo;
 }
 
 - (NSFileHandle *)currentLogFileHandle
 {
-	if (currentLogFileHandle == nil)
-	{
-		NSString *logFilePath = [[self currentLogFileInfo] filePath];
-		
-		currentLogFileHandle = [NSFileHandle fileHandleForWritingAtPath:logFilePath];
-		[currentLogFileHandle seekToEndOfFile];
-		
-		if (currentLogFileHandle)
-		{
-			[self scheduleTimerToRollLogFileDueToAge];
-		}
-	}
-	
-	return currentLogFileHandle;
+    if (currentLogFileHandle == nil)
+    {
+        NSString *logFilePath = [[self currentLogFileInfo] filePath];
+        
+        currentLogFileHandle = [NSFileHandle fileHandleForWritingAtPath:logFilePath];
+        [currentLogFileHandle seekToEndOfFile];
+        
+        if (currentLogFileHandle)
+        {
+            [self scheduleTimerToRollLogFileDueToAge];
+
+            // Here we are monitoring the log file. In case if it would be deleted ormoved
+            // somewhere we want to roll it and use a new one.
+            currentLogFileVnode = dispatch_source_create(
+                DISPATCH_SOURCE_TYPE_VNODE,
+                [currentLogFileHandle fileDescriptor],
+                DISPATCH_VNODE_DELETE | DISPATCH_VNODE_RENAME,
+                loggerQueue
+            );
+
+            dispatch_source_set_event_handler(currentLogFileVnode, ^{ @autoreleasepool {
+                NSLogInfo(@"DDFileLogger: Current logfile was moved. Rolling it and creating a new one");
+                [self rollLogFileNow];
+            }});
+
+            #if !OS_OBJECT_USE_OBJC
+            dispatch_source_t vnode = currentLogFileVnode;
+            dispatch_source_set_cancel_handler(currentLogFileVnode, ^{
+                dispatch_release(vnode);
+            });
+            #endif
+
+            dispatch_resume(currentLogFileVnode);
+        }
+    }
+    
+    return currentLogFileHandle;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma mark DDLogger Protocol
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+static int exception_count = 0;
 - (void)logMessage:(DDLogMessage *)logMessage
 {
-	NSString *logMsg = logMessage->logMsg;
-	
-	if (formatter)
-	{
-		logMsg = [formatter formatLogMessage:logMessage];
-	}
-	
-	if (logMsg)
-	{
-		if (![logMsg hasSuffix:@"\n"])
-		{
-			logMsg = [logMsg stringByAppendingString:@"\n"];
-		}
-		
-		NSData *logData = [logMsg dataUsingEncoding:NSUTF8StringEncoding];
-		
-		[[self currentLogFileHandle] writeData:logData];
-		
-		[self maybeRollLogFileDueToSize];
-	}
+    NSString *logMsg = logMessage->logMsg;
+    
+    if (formatter)
+    {
+        logMsg = [formatter formatLogMessage:logMessage];
+    }
+    
+    if (logMsg)
+    {
+        if (![logMsg hasSuffix:@"\n"])
+        {
+            logMsg = [logMsg stringByAppendingString:@"\n"];
+        }
+        
+        NSData *logData = [logMsg dataUsingEncoding:NSUTF8StringEncoding];
+
+        @try {
+            [[self currentLogFileHandle] writeData:logData];
+
+            [self maybeRollLogFileDueToSize];
+        }
+        @catch (NSException *exception) {
+            exception_count++;
+            if (exception_count <= 10) {
+                NSLogError(@"DDFileLogger.logMessage: %@", exception);
+                if (exception_count == 10)
+                    NSLogError(@"DDFileLogger.logMessage: Too many exceptions -- will not log any more of them.");
+            }
+        }
+    }
 }
 
 - (void)willRemoveLogger
 {
-	// If you override me be sure to invoke [super willRemoveLogger];
-	
-	[self rollLogFileNow];
+    // If you override me be sure to invoke [super willRemoveLogger];
+    
+    [self rollLogFileNow];
 }
 
 - (NSString *)loggerName
 {
-	return @"cocoa.lumberjack.fileLogger";
+    return @"cocoa.lumberjack.fileLogger";
 }
 
 @end
@@ -910,18 +1096,18 @@
 
 #pragma mark Lifecycle
 
-+ (id)logFileWithPath:(NSString *)aFilePath
++ (instancetype)logFileWithPath:(NSString *)aFilePath
 {
-	return [[DDLogFileInfo alloc] initWithFilePath:aFilePath];
+    return [[self alloc] initWithFilePath:aFilePath];
 }
 
-- (id)initWithFilePath:(NSString *)aFilePath
+- (instancetype)initWithFilePath:(NSString *)aFilePath
 {
-	if ((self = [super init]))
-	{
-		filePath = [aFilePath copy];
-	}
-	return self;
+    if ((self = [super init]))
+    {
+        filePath = [aFilePath copy];
+    }
+    return self;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -930,101 +1116,66 @@
 
 - (NSDictionary *)fileAttributes
 {
-	if (fileAttributes == nil)
-	{
-		fileAttributes = [[NSFileManager defaultManager] attributesOfItemAtPath:filePath error:nil];
-	}
-	return fileAttributes;
+    if (fileAttributes == nil)
+    {
+        fileAttributes = [[NSFileManager defaultManager] attributesOfItemAtPath:filePath error:nil];
+    }
+    return fileAttributes;
 }
 
 - (NSString *)fileName
 {
-	if (fileName == nil)
-	{
-		fileName = [filePath lastPathComponent];
-	}
-	return fileName;
+    if (fileName == nil)
+    {
+        fileName = [filePath lastPathComponent];
+    }
+    return fileName;
 }
 
 - (NSDate *)modificationDate
 {
-	if (modificationDate == nil)
-	{
-		modificationDate = [[self fileAttributes] objectForKey:NSFileModificationDate];
-	}
-	
-	return modificationDate;
+    if (modificationDate == nil)
+    {
+        modificationDate = [[self fileAttributes] objectForKey:NSFileModificationDate];
+    }
+    
+    return modificationDate;
 }
 
 - (NSDate *)creationDate
 {
-	if (creationDate == nil)
-	{
-	
-	#if TARGET_OS_IPHONE
-	
-		const char *path = [filePath UTF8String];
-		
-		struct attrlist attrList;
-		memset(&attrList, 0, sizeof(attrList));
-		attrList.bitmapcount = ATTR_BIT_MAP_COUNT;
-		attrList.commonattr = ATTR_CMN_CRTIME;
-		
-		struct {
-			u_int32_t attrBufferSizeInBytes;
-			struct timespec crtime;
-		} attrBuffer;
-		
-		int result = getattrlist(path, &attrList, &attrBuffer, sizeof(attrBuffer), 0);
-		if (result == 0)
-		{
-			double seconds = (double)(attrBuffer.crtime.tv_sec);
-			double nanos   = (double)(attrBuffer.crtime.tv_nsec);
-			
-			NSTimeInterval ti = seconds + (nanos / 1000000000.0);
-			
-			creationDate = [NSDate dateWithTimeIntervalSince1970:ti];
-		}
-		else
-		{
-			NSLogError(@"DDLogFileInfo: creationDate(%@): getattrlist result = %i", self.fileName, result);
-		}
-		
-	#else
-		
-		creationDate = [[self fileAttributes] objectForKey:NSFileCreationDate];
-		
-	#endif
-		
-	}
-	return creationDate;
+    if (creationDate == nil)
+    {
+        creationDate = [[self fileAttributes] objectForKey:NSFileCreationDate];
+    }
+    return creationDate;
 }
 
 - (unsigned long long)fileSize
 {
-	if (fileSize == 0)
-	{
-		fileSize = [[[self fileAttributes] objectForKey:NSFileSize] unsignedLongLongValue];
-	}
-	
-	return fileSize;
+    if (fileSize == 0)
+    {
+        fileSize = [[[self fileAttributes] objectForKey:NSFileSize] unsignedLongLongValue];
+    }
+    
+    return fileSize;
 }
 
 - (NSTimeInterval)age
 {
-	return [[self creationDate] timeIntervalSinceNow] * -1.0;
+    return [[self creationDate] timeIntervalSinceNow] * -1.0;
 }
 
 - (NSString *)description
 {
-	return [@{@"filePath": self.filePath,
-		@"fileName": self.fileName,
-		@"fileAttributes": self.fileAttributes,
-		@"creationDate": self.creationDate,
-		@"modificationDate": self.modificationDate,
-		@"fileSize": @(self.fileSize),
-		@"age": @(self.age),
-		@"isArchived": @(self.isArchived)} description];
+    return [@{@"filePath": self.filePath ?: @"",
+              @"fileName": self.fileName ?: @"",
+              @"fileAttributes": self.fileAttributes ?: @"",
+              @"creationDate": self.creationDate ?: @"",
+              @"modificationDate": self.modificationDate ?: @"",
+              @"fileSize": @(self.fileSize),
+              @"age": @(self.age),
+              @"isArchived": @(self.isArchived)} description];
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1033,43 +1184,43 @@
 
 - (BOOL)isArchived
 {
-	
+    
 #if TARGET_IPHONE_SIMULATOR
-	
-	// Extended attributes don't work properly on the simulator.
-	// So we have to use a less attractive alternative.
-	// See full explanation in the header file.
-	
-	return [self hasExtensionAttributeWithName:XATTR_ARCHIVED_NAME];
-	
+    
+    // Extended attributes don't work properly on the simulator.
+    // So we have to use a less attractive alternative.
+    // See full explanation in the header file.
+    
+    return [self hasExtensionAttributeWithName:XATTR_ARCHIVED_NAME];
+    
 #else
-	
-	return [self hasExtendedAttributeWithName:XATTR_ARCHIVED_NAME];
-	
+    
+    return [self hasExtendedAttributeWithName:XATTR_ARCHIVED_NAME];
+    
 #endif
 }
 
 - (void)setIsArchived:(BOOL)flag
 {
-	
+    
 #if TARGET_IPHONE_SIMULATOR
-	
-	// Extended attributes don't work properly on the simulator.
-	// So we have to use a less attractive alternative.
-	// See full explanation in the header file.
-	
-	if (flag)
-		[self addExtensionAttributeWithName:XATTR_ARCHIVED_NAME];
-	else
-		[self removeExtensionAttributeWithName:XATTR_ARCHIVED_NAME];
-	
+    
+    // Extended attributes don't work properly on the simulator.
+    // So we have to use a less attractive alternative.
+    // See full explanation in the header file.
+    
+    if (flag)
+        [self addExtensionAttributeWithName:XATTR_ARCHIVED_NAME];
+    else
+        [self removeExtensionAttributeWithName:XATTR_ARCHIVED_NAME];
+    
 #else
-	
-	if (flag)
-		[self addExtendedAttributeWithName:XATTR_ARCHIVED_NAME];
-	else
-		[self removeExtendedAttributeWithName:XATTR_ARCHIVED_NAME];
-	
+    
+    if (flag)
+        [self addExtendedAttributeWithName:XATTR_ARCHIVED_NAME];
+    else
+        [self removeExtendedAttributeWithName:XATTR_ARCHIVED_NAME];
+    
 #endif
 }
 
@@ -1079,36 +1230,43 @@
 
 - (void)reset
 {
-	fileName = nil;
-	fileAttributes = nil;
-	creationDate = nil;
-	modificationDate = nil;
+    fileName = nil;
+    fileAttributes = nil;
+    creationDate = nil;
+    modificationDate = nil;
 }
 
 - (void)renameFile:(NSString *)newFileName
 {
-	// This method is only used on the iPhone simulator, where normal extended attributes are broken.
-	// See full explanation in the header file.
-	
-	if (![newFileName isEqualToString:[self fileName]])
-	{
-		NSString *fileDir = [filePath stringByDeletingLastPathComponent];
-		
-		NSString *newFilePath = [fileDir stringByAppendingPathComponent:newFileName];
-		
-		NSLogVerbose(@"DDLogFileInfo: Renaming file: '%@' -> '%@'", self.fileName, newFileName);
-		
-		NSError *error = nil;
-		if (![[NSFileManager defaultManager] moveItemAtPath:filePath toPath:newFilePath error:&error])
-		{
-			NSLogError(@"DDLogFileInfo: Error renaming file (%@): %@", self.fileName, error);
-		}
-		
-		filePath = newFilePath;
-		[self reset];
-	}
+    // This method is only used on the iPhone simulator, where normal extended attributes are broken.
+    // See full explanation in the header file.
+    
+    if (![newFileName isEqualToString:[self fileName]])
+    {
+        NSString *fileDir = [filePath stringByDeletingLastPathComponent];
+        
+        NSString *newFilePath = [fileDir stringByAppendingPathComponent:newFileName];
+        
+        NSLogVerbose(@"DDLogFileInfo: Renaming file: '%@' -> '%@'", self.fileName, newFileName);
+
+        NSError *error = nil;
+        if (![[NSFileManager defaultManager] fileExistsAtPath:newFilePath]){
+            if([[NSFileManager defaultManager] removeItemAtPath:newFilePath error:&error]){
+                NSLogError(@"DDLogFileInfo: Error deleting archive (%@): %@", self.fileName, error);
+            }
+        }
+
+        if (![[NSFileManager defaultManager] moveItemAtPath:filePath toPath:newFilePath error:&error])
+        {
+            NSLogError(@"DDLogFileInfo: Error renaming file (%@): %@", self.fileName, error);
+        }
+
+        filePath = newFilePath;
+        [self reset];
+    }
 }
 
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma mark Attribute Management
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1121,183 +1279,185 @@
 
 - (BOOL)hasExtensionAttributeWithName:(NSString *)attrName
 {
-	// This method is only used on the iPhone simulator, where normal extended attributes are broken.
-	// See full explanation in the header file.
-	
-	// Split the file name into components.
-	// 
-	// log-ABC123.archived.uploaded.txt
-	// 
-	// 0. log-ABC123
-	// 1. archived
-	// 2. uploaded
-	// 3. txt
-	// 
-	// So we want to search for the attrName in the components (ignoring the first and last array indexes).
-	
-	NSArray *components = [[self fileName] componentsSeparatedByString:@"."];
-	
-	// Watch out for file names without an extension
-	
-	NSUInteger count = [components count];
-	NSUInteger max = (count >= 2) ? count-1 : count;
-	
-	NSUInteger i;
-	for (i = 1; i < max; i++)
-	{
-		NSString *attr = [components objectAtIndex:i];
-		
-		if ([attrName isEqualToString:attr])
-		{
-			return YES;
-		}
-	}
-	
-	return NO;
+    // This method is only used on the iPhone simulator, where normal extended attributes are broken.
+    // See full explanation in the header file.
+    
+    // Split the file name into components. File name may have various format, but generally
+    // structure is same:
+    //
+    // <name part>.<extension part> and <name part>.archived.<extension part>
+    // or
+    // <name part> and <name part>.archived
+    //
+    // So we want to search for the attrName in the components (ignoring the first array index).
+    
+    NSArray *components = [[self fileName] componentsSeparatedByString:@"."];
+    
+    // Watch out for file names without an extension
+
+    for (NSUInteger i = 1; i < components.count; i++)
+    {
+        NSString *attr = [components objectAtIndex:i];
+
+        if ([attrName isEqualToString:attr])
+        {
+            return YES;
+        }
+    }
+
+    return NO;
 }
 
 - (void)addExtensionAttributeWithName:(NSString *)attrName
 {
-	// This method is only used on the iPhone simulator, where normal extended attributes are broken.
-	// See full explanation in the header file.
-	
-	if ([attrName length] == 0) return;
-	
-	// Example:
-	// attrName = "archived"
-	// 
-	// "log-ABC123.txt" -> "log-ABC123.archived.txt"
-	
-	NSArray *components = [[self fileName] componentsSeparatedByString:@"."];
-	
-	NSUInteger count = [components count];
-	
-	NSUInteger estimatedNewLength = [[self fileName] length] + [attrName length] + 1;
-	NSMutableString *newFileName = [NSMutableString stringWithCapacity:estimatedNewLength];
-	
-	if (count > 0)
-	{
-		[newFileName appendString:[components objectAtIndex:0]];
-	}
-	
-	NSString *lastExt = @"";
-	
-	NSUInteger i;
-	for (i = 1; i < count; i++)
-	{
-		NSString *attr = [components objectAtIndex:i];
-		if ([attr length] == 0)
-		{
-			continue;
-		}
-		
-		if ([attrName isEqualToString:attr])
-		{
-			// Extension attribute already exists in file name
-			return;
-		}
-		
-		if ([lastExt length] > 0)
-		{
-			[newFileName appendFormat:@".%@", lastExt];
-		}
-		
-		lastExt = attr;
-	}
-	
-	[newFileName appendFormat:@".%@", attrName];
-	
-	if ([lastExt length] > 0)
-	{
-		[newFileName appendFormat:@".%@", lastExt];
-	}
-	
-	[self renameFile:newFileName];
+    // This method is only used on the iPhone simulator, where normal extended attributes are broken.
+    // See full explanation in the header file.
+    
+    if ([attrName length] == 0) return;
+    
+    // Example:
+    // attrName = "archived"
+    //
+    // "mylog.txt" -> "mylog.archived.txt"
+    // "mylog"     -> "mylog.archived"
+
+    NSArray *components = [[self fileName] componentsSeparatedByString:@"."];
+    
+    NSUInteger count = [components count];
+    
+    NSUInteger estimatedNewLength = [[self fileName] length] + [attrName length] + 1;
+    NSMutableString *newFileName = [NSMutableString stringWithCapacity:estimatedNewLength];
+    
+    if (count > 0)
+    {
+        [newFileName appendString:[components objectAtIndex:0]];
+    }
+    
+    NSString *lastExt = @"";
+    
+    NSUInteger i;
+    for (i = 1; i < count; i++)
+    {
+        NSString *attr = [components objectAtIndex:i];
+        if ([attr length] == 0)
+        {
+            continue;
+        }
+        
+        if ([attrName isEqualToString:attr])
+        {
+            // Extension attribute already exists in file name
+            return;
+        }
+        
+        if ([lastExt length] > 0)
+        {
+            [newFileName appendFormat:@".%@", lastExt];
+        }
+        
+        lastExt = attr;
+    }
+    
+    [newFileName appendFormat:@".%@", attrName];
+    
+    if ([lastExt length] > 0)
+    {
+        [newFileName appendFormat:@".%@", lastExt];
+    }
+    
+    [self renameFile:newFileName];
 }
 
 - (void)removeExtensionAttributeWithName:(NSString *)attrName
 {
-	// This method is only used on the iPhone simulator, where normal extended attributes are broken.
-	// See full explanation in the header file.
-	
-	if ([attrName length] == 0) return;
-	
-	// Example:
-	// attrName = "archived"
-	// 
-	// "log-ABC123.txt" -> "log-ABC123.archived.txt"
-	
-	NSArray *components = [[self fileName] componentsSeparatedByString:@"."];
-	
-	NSUInteger count = [components count];
-	
-	NSUInteger estimatedNewLength = [[self fileName] length];
-	NSMutableString *newFileName = [NSMutableString stringWithCapacity:estimatedNewLength];
-	
-	if (count > 0)
-	{
-		[newFileName appendString:[components objectAtIndex:0]];
-	}
-	
-	BOOL found = NO;
-	
-	NSUInteger i;
-	for (i = 1; i < count; i++)
-	{
-		NSString *attr = [components objectAtIndex:i];
-		
-		if ([attrName isEqualToString:attr])
-		{
-			found = YES;
-		}
-		else
-		{
-			[newFileName appendFormat:@".%@", attr];
-		}
-	}
-	
-	if (found)
-	{
-		[self renameFile:newFileName];
-	}
+    // This method is only used on the iPhone simulator, where normal extended attributes are broken.
+    // See full explanation in the header file.
+    
+    if ([attrName length] == 0) return;
+    
+    // Example:
+    // attrName = "archived"
+    // 
+    // "mylog.archived.txt" -> "mylog.txt"
+    // "mylog.archived"     -> "mylog"
+    
+    NSArray *components = [[self fileName] componentsSeparatedByString:@"."];
+    
+    NSUInteger count = [components count];
+    
+    NSUInteger estimatedNewLength = [[self fileName] length];
+    NSMutableString *newFileName = [NSMutableString stringWithCapacity:estimatedNewLength];
+    
+    if (count > 0)
+    {
+        [newFileName appendString:[components objectAtIndex:0]];
+    }
+    
+    BOOL found = NO;
+    
+    NSUInteger i;
+    for (i = 1; i < count; i++)
+    {
+        NSString *attr = [components objectAtIndex:i];
+        
+        if ([attrName isEqualToString:attr])
+        {
+            found = YES;
+        }
+        else
+        {
+            [newFileName appendFormat:@".%@", attr];
+        }
+    }
+    
+    if (found)
+    {
+        [self renameFile:newFileName];
+    }
 }
 
 #else
 
 - (BOOL)hasExtendedAttributeWithName:(NSString *)attrName
 {
-	const char *path = [filePath UTF8String];
-	const char *name = [attrName UTF8String];
-	
-	ssize_t result = getxattr(path, name, NULL, 0, 0, 0);
-	
-	return (result >= 0);
+    const char *path = [filePath UTF8String];
+    const char *name = [attrName UTF8String];
+    
+    ssize_t result = getxattr(path, name, NULL, 0, 0, 0);
+    
+    return (result >= 0);
 }
 
 - (void)addExtendedAttributeWithName:(NSString *)attrName
 {
-	const char *path = [filePath UTF8String];
-	const char *name = [attrName UTF8String];
-	
-	int result = setxattr(path, name, NULL, 0, 0, 0);
-	
-	if (result < 0)
-	{
-		NSLogError(@"DDLogFileInfo: setxattr(%@, %@): error = %i", attrName, self.fileName, result);
-	}
+    const char *path = [filePath UTF8String];
+    const char *name = [attrName UTF8String];
+    
+    int result = setxattr(path, name, NULL, 0, 0, 0);
+    
+    if (result < 0)
+    {
+        NSLogError(@"DDLogFileInfo: setxattr(%@, %@): error = %s",
+                   attrName,
+                   self.fileName,
+                   strerror(errno));
+    }
 }
 
 - (void)removeExtendedAttributeWithName:(NSString *)attrName
 {
-	const char *path = [filePath UTF8String];
-	const char *name = [attrName UTF8String];
-	
-	int result = removexattr(path, name, 0);
-	
-	if (result < 0 && errno != ENOATTR)
-	{
-		NSLogError(@"DDLogFileInfo: removexattr(%@, %@): error = %i", attrName, self.fileName, result);
-	}
+    const char *path = [filePath UTF8String];
+    const char *name = [attrName UTF8String];
+    
+    int result = removexattr(path, name, 0);
+    
+    if (result < 0 && errno != ENOATTR)
+    {
+        NSLogError(@"DDLogFileInfo: removexattr(%@, %@): error = %s",
+                   attrName,
+                   self.fileName,
+                   strerror(errno));
+    }
 }
 
 #endif
@@ -1308,46 +1468,72 @@
 
 - (BOOL)isEqual:(id)object
 {
-	if ([object isKindOfClass:[self class]])
-	{
-		DDLogFileInfo *another = (DDLogFileInfo *)object;
-		
-		return [filePath isEqualToString:[another filePath]];
-	}
-	
-	return NO;
+    if ([object isKindOfClass:[self class]])
+    {
+        DDLogFileInfo *another = (DDLogFileInfo *)object;
+        
+        return [filePath isEqualToString:[another filePath]];
+    }
+    
+    return NO;
 }
 
 - (NSComparisonResult)reverseCompareByCreationDate:(DDLogFileInfo *)another
 {
-	NSDate *us = [self creationDate];
-	NSDate *them = [another creationDate];
-	
-	NSComparisonResult result = [us compare:them];
-	
-	if (result == NSOrderedAscending)
-		return NSOrderedDescending;
-	
-	if (result == NSOrderedDescending)
-		return NSOrderedAscending;
-	
-	return NSOrderedSame;
+    NSDate *us = [self creationDate];
+    NSDate *them = [another creationDate];
+    
+    NSComparisonResult result = [us compare:them];
+    
+    if (result == NSOrderedAscending)
+        return NSOrderedDescending;
+    
+    if (result == NSOrderedDescending)
+        return NSOrderedAscending;
+    
+    return NSOrderedSame;
 }
 
 - (NSComparisonResult)reverseCompareByModificationDate:(DDLogFileInfo *)another
 {
-	NSDate *us = [self modificationDate];
-	NSDate *them = [another modificationDate];
-	
-	NSComparisonResult result = [us compare:them];
-	
-	if (result == NSOrderedAscending)
-		return NSOrderedDescending;
-	
-	if (result == NSOrderedDescending)
-		return NSOrderedAscending;
-	
-	return NSOrderedSame;
+    NSDate *us = [self modificationDate];
+    NSDate *them = [another modificationDate];
+    
+    NSComparisonResult result = [us compare:them];
+    
+    if (result == NSOrderedAscending)
+        return NSOrderedDescending;
+    
+    if (result == NSOrderedDescending)
+        return NSOrderedAscending;
+    
+    return NSOrderedSame;
 }
 
 @end
+
+#if TARGET_OS_IPHONE
+/**
+ * When creating log file on iOS we're setting NSFileProtectionKey attribute to NSFileProtectionCompleteUnlessOpen.
+ *
+ * But in case if app is able to launch from background we need to have an ability to open log file any time we
+ * want (even if device is locked). Thats why that attribute have to be changed to
+ * NSFileProtectionCompleteUntilFirstUserAuthentication.
+ */
+BOOL doesAppRunInBackground()
+{
+    BOOL answer = NO;
+
+    NSArray *backgroundModes = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"UIBackgroundModes"];
+
+    for (NSString *mode in backgroundModes) {
+        if (mode.length > 0) {
+            answer = YES;
+            break;
+        }
+    }
+
+    return answer;
+}
+#endif
+