1713 lines
58 KiB
Objective-C
1713 lines
58 KiB
Objective-C
// Software License Agreement (BSD License)
|
|
//
|
|
// Copyright (c) 2010-2019, Deusty, LLC
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use of this software in source and binary forms,
|
|
// with or without modification, are permitted provided that the following conditions are met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright notice,
|
|
// this list of conditions and the following disclaimer.
|
|
//
|
|
// * Neither the name of Deusty nor the names of its contributors may be used
|
|
// to endorse or promote products derived from this software without specific
|
|
// prior written permission of Deusty, LLC.
|
|
|
|
#import "DDFileLogger.h"
|
|
|
|
#import "DDFileLogger+Internal.h"
|
|
|
|
#import <sys/xattr.h>
|
|
|
|
#if !__has_feature(objc_arc)
|
|
#error This file must be compiled with ARC. Use -fobjc-arc flag (or convert project to ARC).
|
|
#endif
|
|
|
|
// We probably shouldn't be using DDLog() statements within the DDLog implementation.
|
|
// But we still want to leave our log statements for any future debugging,
|
|
// and to allow other developers to trace the implementation (which is a great learning tool).
|
|
//
|
|
// So we use primitive logging macros around NSLog.
|
|
// We maintain the NS prefix on the macros to be explicit about the fact that we're using NSLog.
|
|
|
|
#ifndef DD_NSLOG_LEVEL
|
|
#define DD_NSLOG_LEVEL 2
|
|
#endif
|
|
|
|
#define NSLogError(frmt, ...) do{ if(DD_NSLOG_LEVEL >= 1) NSLog((frmt), ##__VA_ARGS__); } while(0)
|
|
#define NSLogWarn(frmt, ...) do{ if(DD_NSLOG_LEVEL >= 2) NSLog((frmt), ##__VA_ARGS__); } while(0)
|
|
#define NSLogInfo(frmt, ...) do{ if(DD_NSLOG_LEVEL >= 3) NSLog((frmt), ##__VA_ARGS__); } while(0)
|
|
#define NSLogDebug(frmt, ...) do{ if(DD_NSLOG_LEVEL >= 4) NSLog((frmt), ##__VA_ARGS__); } while(0)
|
|
#define NSLogVerbose(frmt, ...) do{ if(DD_NSLOG_LEVEL >= 5) NSLog((frmt), ##__VA_ARGS__); } while(0)
|
|
|
|
|
|
#if TARGET_OS_IPHONE
|
|
BOOL doesAppRunInBackground(void);
|
|
#endif
|
|
|
|
unsigned long long const kDDDefaultLogMaxFileSize = 1024 * 1024; // 1 MB
|
|
NSTimeInterval const kDDDefaultLogRollingFrequency = 60 * 60 * 24; // 24 Hours
|
|
NSUInteger const kDDDefaultLogMaxNumLogFiles = 5; // 5 Files
|
|
unsigned long long const kDDDefaultLogFilesDiskQuota = 20 * 1024 * 1024; // 20 MB
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#pragma mark -
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
@interface DDLogFileManagerDefault () {
|
|
NSUInteger _maximumNumberOfLogFiles;
|
|
unsigned long long _logFilesDiskQuota;
|
|
NSString *_logsDirectory;
|
|
#if TARGET_OS_IPHONE
|
|
NSFileProtectionType _defaultFileProtectionLevel;
|
|
#endif
|
|
}
|
|
|
|
@end
|
|
|
|
@implementation DDLogFileManagerDefault
|
|
|
|
@synthesize maximumNumberOfLogFiles = _maximumNumberOfLogFiles;
|
|
@synthesize logFilesDiskQuota = _logFilesDiskQuota;
|
|
|
|
- (instancetype)init {
|
|
return [self initWithLogsDirectory:nil];
|
|
}
|
|
|
|
- (instancetype)initWithLogsDirectory:(NSString * __nullable)aLogsDirectory {
|
|
if ((self = [super init])) {
|
|
_maximumNumberOfLogFiles = kDDDefaultLogMaxNumLogFiles;
|
|
_logFilesDiskQuota = kDDDefaultLogFilesDiskQuota;
|
|
|
|
if (aLogsDirectory.length > 0) {
|
|
_logsDirectory = [aLogsDirectory copy];
|
|
} else {
|
|
_logsDirectory = [[self defaultLogsDirectory] copy];
|
|
}
|
|
|
|
NSKeyValueObservingOptions kvoOptions = NSKeyValueObservingOptionOld | NSKeyValueObservingOptionNew;
|
|
|
|
[self addObserver:self forKeyPath:NSStringFromSelector(@selector(maximumNumberOfLogFiles)) options:kvoOptions context:nil];
|
|
[self addObserver:self forKeyPath:NSStringFromSelector(@selector(logFilesDiskQuota)) options:kvoOptions context:nil];
|
|
|
|
NSLogVerbose(@"DDFileLogManagerDefault: logsDirectory:\n%@", [self logsDirectory]);
|
|
NSLogVerbose(@"DDFileLogManagerDefault: sortedLogFileNames:\n%@", [self sortedLogFileNames]);
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
+ (BOOL)automaticallyNotifiesObserversForKey:(NSString *)theKey {
|
|
|
|
if ([theKey isEqualToString:@"maximumNumberOfLogFiles"] || [theKey isEqualToString:@"logFilesDiskQuota"]) {
|
|
return NO;
|
|
} else {
|
|
return [super automaticallyNotifiesObserversForKey:theKey];
|
|
}
|
|
}
|
|
|
|
#if TARGET_OS_IPHONE
|
|
- (instancetype)initWithLogsDirectory:(NSString *)logsDirectory
|
|
defaultFileProtectionLevel:(NSFileProtectionType)fileProtectionLevel {
|
|
|
|
if ((self = [self initWithLogsDirectory:logsDirectory])) {
|
|
if ([fileProtectionLevel isEqualToString:NSFileProtectionNone] ||
|
|
[fileProtectionLevel isEqualToString:NSFileProtectionComplete] ||
|
|
[fileProtectionLevel isEqualToString:NSFileProtectionCompleteUnlessOpen] ||
|
|
[fileProtectionLevel isEqualToString:NSFileProtectionCompleteUntilFirstUserAuthentication]) {
|
|
_defaultFileProtectionLevel = fileProtectionLevel;
|
|
}
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
#endif
|
|
|
|
- (void)dealloc {
|
|
// 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))];
|
|
[self removeObserver:self forKeyPath:NSStringFromSelector(@selector(logFilesDiskQuota))];
|
|
} @catch (NSException *exception) {
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#pragma mark Configuration
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
- (void)observeValueForKeyPath:(NSString *)keyPath
|
|
ofObject:(__unused id)object
|
|
change:(NSDictionary *)change
|
|
context:(__unused void *)context {
|
|
NSNumber *old = change[NSKeyValueChangeOldKey];
|
|
NSNumber *new = change[NSKeyValueChangeNewKey];
|
|
|
|
if ([old isEqual:new]) {
|
|
return;
|
|
}
|
|
|
|
if ([keyPath isEqualToString:NSStringFromSelector(@selector(maximumNumberOfLogFiles))] ||
|
|
[keyPath isEqualToString:NSStringFromSelector(@selector(logFilesDiskQuota))]) {
|
|
NSLogInfo(@"DDFileLogManagerDefault: Responding to configuration change: %@", keyPath);
|
|
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
@autoreleasepool {
|
|
// See method header for queue reasoning.
|
|
[self deleteOldLogFiles];
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
#if TARGET_OS_IPHONE
|
|
- (NSFileProtectionType)logFileProtection {
|
|
if (_defaultFileProtectionLevel.length > 0) {
|
|
return _defaultFileProtectionLevel;
|
|
} else if (doesAppRunInBackground()) {
|
|
return NSFileProtectionCompleteUntilFirstUserAuthentication;
|
|
} else {
|
|
return NSFileProtectionCompleteUnlessOpen;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#pragma mark File Deleting
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/**
|
|
* Deletes archived log files that exceed the maximumNumberOfLogFiles or logFilesDiskQuota configuration values.
|
|
* Method may take a while to execute since we're performing IO. It's not critical that this is synchronized with
|
|
* log output, since the files we're deleting are all archived and not in use, therefore this method is called on a
|
|
* background queue.
|
|
**/
|
|
- (void)deleteOldLogFiles {
|
|
NSLogVerbose(@"DDLogFileManagerDefault: deleteOldLogFiles");
|
|
|
|
NSArray *sortedLogFileInfos = [self sortedLogFileInfos];
|
|
NSUInteger firstIndexToDelete = NSNotFound;
|
|
|
|
const unsigned long long diskQuota = self.logFilesDiskQuota;
|
|
const NSUInteger maxNumLogFiles = self.maximumNumberOfLogFiles;
|
|
|
|
if (diskQuota) {
|
|
unsigned long long used = 0;
|
|
|
|
for (NSUInteger i = 0; i < sortedLogFileInfos.count; i++) {
|
|
DDLogFileInfo *info = sortedLogFileInfos[i];
|
|
used += info.fileSize;
|
|
|
|
if (used > diskQuota) {
|
|
firstIndexToDelete = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (maxNumLogFiles) {
|
|
if (firstIndexToDelete == NSNotFound) {
|
|
firstIndexToDelete = maxNumLogFiles;
|
|
} else {
|
|
firstIndexToDelete = MIN(firstIndexToDelete, maxNumLogFiles);
|
|
}
|
|
}
|
|
|
|
if (firstIndexToDelete == 0) {
|
|
// 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.
|
|
|
|
if (sortedLogFileInfos.count > 0) {
|
|
DDLogFileInfo *logFileInfo = sortedLogFileInfos[0];
|
|
|
|
if (!logFileInfo.isArchived) {
|
|
// Don't delete active file.
|
|
++firstIndexToDelete;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (firstIndexToDelete != NSNotFound) {
|
|
// removing all log files starting with firstIndexToDelete
|
|
|
|
for (NSUInteger i = firstIndexToDelete; i < sortedLogFileInfos.count; i++) {
|
|
DDLogFileInfo *logFileInfo = sortedLogFileInfos[i];
|
|
|
|
NSError *error = nil;
|
|
BOOL success = [[NSFileManager defaultManager] removeItemAtPath:logFileInfo.filePath error:&error];
|
|
if (success) {
|
|
NSLogInfo(@"DDLogFileManagerDefault: Deleting file: %@", logFileInfo.fileName);
|
|
} else {
|
|
NSLogError(@"DDLogFileManagerDefault: Error deleting file %@", error);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#pragma mark Log Files
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/**
|
|
* Returns the path to the default logs directory.
|
|
* If the logs directory doesn't exist, this method automatically creates it.
|
|
**/
|
|
- (NSString *)defaultLogsDirectory {
|
|
|
|
#if TARGET_OS_IPHONE
|
|
NSArray *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
|
|
NSString *baseDir = paths.firstObject;
|
|
NSString *logsDirectory = [baseDir stringByAppendingPathComponent:@"Logs"];
|
|
#else
|
|
NSString *appName = [[NSProcessInfo processInfo] processName];
|
|
NSArray *paths = NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES);
|
|
NSString *basePath = ([paths count] > 0) ? paths[0] : NSTemporaryDirectory();
|
|
NSString *logsDirectory = [[basePath stringByAppendingPathComponent:@"Logs"] stringByAppendingPathComponent:appName];
|
|
#endif
|
|
|
|
return logsDirectory;
|
|
}
|
|
|
|
- (NSString *)logsDirectory {
|
|
// We could do this check once, during initialization, and not bother again.
|
|
// But this way the code continues to work if the directory gets deleted while the code is running.
|
|
|
|
NSAssert(_logsDirectory.length > 0, @"Directory must be set.");
|
|
|
|
NSError *err = nil;
|
|
BOOL success = [[NSFileManager defaultManager] createDirectoryAtPath:_logsDirectory
|
|
withIntermediateDirectories:YES
|
|
attributes:nil
|
|
error:&err];
|
|
if (success == NO) {
|
|
NSLogError(@"DDFileLogManagerDefault: Error creating logsDirectory: %@", err);
|
|
}
|
|
|
|
return _logsDirectory;
|
|
}
|
|
|
|
- (BOOL)isLogFile:(NSString *)fileName {
|
|
NSString *appName = [self applicationName];
|
|
|
|
// We need to add a space to the name as otherwise we could match applications that have the name prefix.
|
|
BOOL hasProperPrefix = [fileName hasPrefix:[appName stringByAppendingString:@" "]];
|
|
BOOL hasProperSuffix = [fileName hasSuffix:@".log"];
|
|
|
|
return (hasProperPrefix && hasProperSuffix);
|
|
}
|
|
|
|
// if you change formatter, then change sortedLogFileInfos method also accordingly
|
|
- (NSDateFormatter *)logFileDateFormatter {
|
|
NSMutableDictionary *dictionary = [[NSThread currentThread] threadDictionary];
|
|
NSString *dateFormat = @"yyyy'-'MM'-'dd'--'HH'-'mm'-'ss'-'SSS'";
|
|
NSString *key = [NSString stringWithFormat:@"logFileDateFormatter.%@", dateFormat];
|
|
NSDateFormatter *dateFormatter = dictionary[key];
|
|
|
|
if (dateFormatter == nil) {
|
|
dateFormatter = [[NSDateFormatter alloc] init];
|
|
[dateFormatter setLocale:[NSLocale localeWithLocaleIdentifier:@"en_US_POSIX"]];
|
|
[dateFormatter setDateFormat:dateFormat];
|
|
[dateFormatter setTimeZone:[NSTimeZone timeZoneForSecondsFromGMT:0]];
|
|
dictionary[key] = dateFormatter;
|
|
}
|
|
|
|
return dateFormatter;
|
|
}
|
|
|
|
- (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 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;
|
|
}
|
|
|
|
- (NSArray *)unsortedLogFileNames {
|
|
NSArray *unsortedLogFilePaths = [self unsortedLogFilePaths];
|
|
|
|
NSMutableArray *unsortedLogFileNames = [NSMutableArray arrayWithCapacity:[unsortedLogFilePaths count]];
|
|
|
|
for (NSString *filePath in unsortedLogFilePaths) {
|
|
[unsortedLogFileNames addObject:[filePath lastPathComponent]];
|
|
}
|
|
|
|
return unsortedLogFileNames;
|
|
}
|
|
|
|
- (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 *)sortedLogFilePaths {
|
|
NSArray *sortedLogFileInfos = [self sortedLogFileInfos];
|
|
|
|
NSMutableArray *sortedLogFilePaths = [NSMutableArray arrayWithCapacity:[sortedLogFileInfos count]];
|
|
|
|
for (DDLogFileInfo *logFileInfo in sortedLogFileInfos) {
|
|
[sortedLogFilePaths addObject:[logFileInfo filePath]];
|
|
}
|
|
|
|
return sortedLogFilePaths;
|
|
}
|
|
|
|
- (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 {
|
|
return [[self unsortedLogFileInfos] sortedArrayUsingComparator:^NSComparisonResult(DDLogFileInfo *obj1,
|
|
DDLogFileInfo *obj2) {
|
|
NSDate *date1 = [NSDate new];
|
|
NSDate *date2 = [NSDate new];
|
|
|
|
NSArray<NSString *> *arrayComponent = [[obj1 fileName] componentsSeparatedByString:@" "];
|
|
if (arrayComponent.count > 0) {
|
|
NSString *stringDate = arrayComponent.lastObject;
|
|
stringDate = [stringDate stringByReplacingOccurrencesOfString:@".log" withString:@""];
|
|
stringDate = [stringDate stringByReplacingOccurrencesOfString:@".archived" withString:@""];
|
|
date1 = [[self logFileDateFormatter] dateFromString:stringDate] ?: [obj1 creationDate];
|
|
}
|
|
|
|
arrayComponent = [[obj2 fileName] componentsSeparatedByString:@" "];
|
|
if (arrayComponent.count > 0) {
|
|
NSString *stringDate = arrayComponent.lastObject;
|
|
stringDate = [stringDate stringByReplacingOccurrencesOfString:@".log" withString:@""];
|
|
stringDate = [stringDate stringByReplacingOccurrencesOfString:@".archived" withString:@""];
|
|
date2 = [[self logFileDateFormatter] dateFromString:stringDate] ?: [obj2 creationDate];
|
|
}
|
|
|
|
return [date2 compare:date1 ?: [NSDate new]];
|
|
}];
|
|
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#pragma mark Creation
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//if you change newLogFileName , then change isLogFile method also accordingly
|
|
- (NSString *)newLogFileName {
|
|
NSString *appName = [self applicationName];
|
|
|
|
NSDateFormatter *dateFormatter = [self logFileDateFormatter];
|
|
NSString *formattedDate = [dateFormatter stringFromDate:[NSDate date]];
|
|
|
|
return [NSString stringWithFormat:@"%@ %@.log", appName, formattedDate];
|
|
}
|
|
|
|
- (NSString * __nullable)logFileHeader {
|
|
return nil;
|
|
}
|
|
|
|
- (NSData *)logFileHeaderData {
|
|
NSString *fileHeaderStr = [self logFileHeader];
|
|
|
|
if (fileHeaderStr.length == 0) {
|
|
return nil;
|
|
}
|
|
|
|
if (![fileHeaderStr hasSuffix:@"\n"]) {
|
|
fileHeaderStr = [fileHeaderStr stringByAppendingString:@"\n"];
|
|
}
|
|
|
|
return [fileHeaderStr dataUsingEncoding:NSUTF8StringEncoding];
|
|
}
|
|
|
|
- (NSString *)createNewLogFile {
|
|
static NSUInteger MAX_ALLOWED_ERROR = 5;
|
|
|
|
NSString *fileName = [self newLogFileName];
|
|
NSString *logsDirectory = [self logsDirectory];
|
|
NSData *fileHeader = [self logFileHeaderData];
|
|
if (fileHeader == nil) {
|
|
fileHeader = [NSData new];
|
|
}
|
|
|
|
NSUInteger attempt = 1;
|
|
NSUInteger criticalErrors = 0;
|
|
|
|
do {
|
|
if (criticalErrors >= MAX_ALLOWED_ERROR) {
|
|
NSLogError(@"DDLogFileManagerDefault: Bailing file creation, encountered %ld errors.",
|
|
(unsigned long)criticalErrors);
|
|
return nil;
|
|
}
|
|
|
|
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];
|
|
|
|
NSError *error = nil;
|
|
BOOL success = [fileHeader writeToFile:filePath options:NSAtomicWrite error:&error];
|
|
|
|
#if TARGET_OS_IPHONE
|
|
if (success) {
|
|
// 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.
|
|
NSDictionary *attributes = @{NSFileProtectionKey: [self logFileProtection]};
|
|
success = [[NSFileManager defaultManager] setAttributes:attributes
|
|
ofItemAtPath:filePath
|
|
error:&error];
|
|
}
|
|
#endif
|
|
|
|
if (success) {
|
|
NSLogVerbose(@"PURLogFileManagerDefault: Created new log file: %@", actualFileName);
|
|
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
|
|
// Since we just created a new log file, we may need to delete some old log files
|
|
[self deleteOldLogFiles];
|
|
});
|
|
return filePath;
|
|
} else if (error.code == NSFileWriteFileExistsError) {
|
|
attempt++;
|
|
continue;
|
|
} else {
|
|
NSLogError(@"PURLogFileManagerDefault: Critical error while creating log file: %@", error);
|
|
criticalErrors++;
|
|
continue;
|
|
}
|
|
|
|
return filePath;
|
|
} 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.length == 0) {
|
|
_appName = [[NSProcessInfo processInfo] processName];
|
|
}
|
|
|
|
if (_appName.length == 0) {
|
|
_appName = @"";
|
|
}
|
|
});
|
|
|
|
return _appName;
|
|
}
|
|
|
|
@end
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#pragma mark -
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
@interface DDLogFileFormatterDefault () {
|
|
NSDateFormatter *_dateFormatter;
|
|
}
|
|
|
|
@end
|
|
|
|
@implementation DDLogFileFormatterDefault
|
|
|
|
- (instancetype)init {
|
|
return [self initWithDateFormatter:nil];
|
|
}
|
|
|
|
- (instancetype)initWithDateFormatter:(NSDateFormatter * __nullable)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;
|
|
}
|
|
|
|
- (NSString *)formatLogMessage:(DDLogMessage *)logMessage {
|
|
NSString *dateAndTime = [_dateFormatter stringFromDate:(logMessage->_timestamp)];
|
|
|
|
return [NSString stringWithFormat:@"%@ %@", dateAndTime, logMessage->_message];
|
|
}
|
|
|
|
@end
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#pragma mark -
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
@interface DDFileLogger () {
|
|
id <DDLogFileManager> _logFileManager;
|
|
|
|
DDLogFileInfo *_currentLogFileInfo;
|
|
NSFileHandle *_currentLogFileHandle;
|
|
|
|
dispatch_source_t _currentLogFileVnode;
|
|
|
|
NSTimeInterval _rollingFrequency;
|
|
dispatch_source_t _rollingTimer;
|
|
|
|
unsigned long long _maximumFileSize;
|
|
|
|
dispatch_queue_t _completionQueue;
|
|
}
|
|
|
|
@end
|
|
|
|
@implementation DDFileLogger
|
|
|
|
- (instancetype)init {
|
|
DDLogFileManagerDefault *defaultLogFileManager = [[DDLogFileManagerDefault alloc] init];
|
|
return [self initWithLogFileManager:defaultLogFileManager completionQueue:nil];
|
|
}
|
|
|
|
- (instancetype)initWithLogFileManager:(id<DDLogFileManager>)logFileManager {
|
|
return [self initWithLogFileManager:logFileManager completionQueue:nil];
|
|
}
|
|
|
|
- (instancetype)initWithLogFileManager:(id <DDLogFileManager>)aLogFileManager
|
|
completionQueue:(dispatch_queue_t __nullable)dispatchQueue {
|
|
if ((self = [super init])) {
|
|
_completionQueue = dispatchQueue ?: dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
|
|
|
|
_maximumFileSize = kDDDefaultLogMaxFileSize;
|
|
_rollingFrequency = kDDDefaultLogRollingFrequency;
|
|
_automaticallyAppendNewlineForCustomFormatters = YES;
|
|
|
|
_logFileManager = aLogFileManager;
|
|
_logFormatter = [DDLogFileFormatterDefault new];
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
- (void)lt_cleanup {
|
|
NSAssert([self isOnInternalLoggerQueue], @"lt_ methods should be on logger queue.");
|
|
|
|
[_currentLogFileHandle synchronizeFile];
|
|
[_currentLogFileHandle closeFile];
|
|
|
|
if (_currentLogFileVnode) {
|
|
dispatch_source_cancel(_currentLogFileVnode);
|
|
_currentLogFileVnode = NULL;
|
|
}
|
|
|
|
if (_rollingTimer) {
|
|
dispatch_source_cancel(_rollingTimer);
|
|
_rollingTimer = NULL;
|
|
}
|
|
}
|
|
|
|
- (void)dealloc {
|
|
if (self.isOnInternalLoggerQueue) {
|
|
[self lt_cleanup];
|
|
} else {
|
|
dispatch_sync(self.loggerQueue, ^{
|
|
[self lt_cleanup];
|
|
});
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#pragma mark Properties
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
- (unsigned long long)maximumFileSize {
|
|
__block unsigned long long result;
|
|
|
|
dispatch_block_t block = ^{
|
|
result = self->_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(self.loggerQueue, block);
|
|
});
|
|
|
|
return result;
|
|
}
|
|
|
|
- (void)setMaximumFileSize:(unsigned long long)newMaximumFileSize {
|
|
dispatch_block_t block = ^{
|
|
@autoreleasepool {
|
|
self->_maximumFileSize = newMaximumFileSize;
|
|
[self lt_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(self.loggerQueue, block);
|
|
});
|
|
}
|
|
|
|
- (NSTimeInterval)rollingFrequency {
|
|
__block NSTimeInterval result;
|
|
|
|
dispatch_block_t block = ^{
|
|
result = self->_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(self.loggerQueue, block);
|
|
});
|
|
|
|
return result;
|
|
}
|
|
|
|
- (void)setRollingFrequency:(NSTimeInterval)newRollingFrequency {
|
|
dispatch_block_t block = ^{
|
|
@autoreleasepool {
|
|
self->_rollingFrequency = newRollingFrequency;
|
|
[self lt_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(self.loggerQueue, block);
|
|
});
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#pragma mark File Rolling
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
- (void)lt_scheduleTimerToRollLogFileDueToAge {
|
|
NSAssert([self isOnInternalLoggerQueue], @"lt_ methods should be on logger queue.");
|
|
|
|
if (_rollingTimer) {
|
|
dispatch_source_cancel(_rollingTimer);
|
|
_rollingTimer = NULL;
|
|
}
|
|
|
|
if (_currentLogFileInfo == nil || _rollingFrequency <= 0.0) {
|
|
return;
|
|
}
|
|
|
|
NSDate *logFileCreationDate = [_currentLogFileInfo creationDate];
|
|
NSTimeInterval frequency = MIN(_rollingFrequency, DBL_MAX - [logFileCreationDate timeIntervalSinceReferenceDate]);
|
|
NSDate *logFileRollingDate = [logFileCreationDate dateByAddingTimeInterval:frequency];
|
|
|
|
NSLogVerbose(@"DDFileLogger: scheduleTimerToRollLogFileDueToAge");
|
|
NSLogVerbose(@"DDFileLogger: logFileCreationDate : %@", logFileCreationDate);
|
|
NSLogVerbose(@"DDFileLogger: actual rollingFrequency: %f", frequency);
|
|
NSLogVerbose(@"DDFileLogger: logFileRollingDate : %@", logFileRollingDate);
|
|
|
|
_rollingTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, _loggerQueue);
|
|
|
|
__weak __auto_type weakSelf = self;
|
|
dispatch_source_set_event_handler(_rollingTimer, ^{ @autoreleasepool {
|
|
[weakSelf lt_maybeRollLogFileDueToAge];
|
|
} });
|
|
|
|
#if !OS_OBJECT_USE_OBJC
|
|
dispatch_source_t theRollingTimer = _rollingTimer;
|
|
dispatch_source_set_cancel_handler(_rollingTimer, ^{
|
|
dispatch_release(theRollingTimer);
|
|
});
|
|
#endif
|
|
|
|
static NSTimeInterval const kDDMaxTimerDelay = LLONG_MAX / NSEC_PER_SEC;
|
|
int64_t delay = (int64_t)(MIN([logFileRollingDate timeIntervalSinceNow], kDDMaxTimerDelay) * (NSTimeInterval) NSEC_PER_SEC);
|
|
dispatch_time_t fireTime = dispatch_time(DISPATCH_TIME_NOW, delay);
|
|
|
|
dispatch_source_set_timer(_rollingTimer, fireTime, DISPATCH_TIME_FOREVER, 1ull * NSEC_PER_SEC);
|
|
dispatch_resume(_rollingTimer);
|
|
}
|
|
|
|
- (void)rollLogFile {
|
|
[self rollLogFileWithCompletionBlock:nil];
|
|
}
|
|
|
|
- (void)rollLogFileWithCompletionBlock:(void (^ __nullable)(void))completionBlock {
|
|
// This method is public.
|
|
// We need to execute the rolling on our logging thread/queue.
|
|
|
|
dispatch_block_t block = ^{
|
|
@autoreleasepool {
|
|
[self lt_rollLogFileNow];
|
|
|
|
if (completionBlock) {
|
|
dispatch_async(self->_completionQueue, ^{
|
|
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(self.loggerQueue, block);
|
|
});
|
|
}
|
|
}
|
|
|
|
- (void)lt_rollLogFileNow {
|
|
NSAssert([self isOnInternalLoggerQueue], @"lt_ methods should be on logger queue.");
|
|
NSLogVerbose(@"DDFileLogger: rollLogFileNow");
|
|
|
|
if (_currentLogFileHandle == nil) {
|
|
return;
|
|
}
|
|
|
|
[_currentLogFileHandle synchronizeFile];
|
|
[_currentLogFileHandle closeFile];
|
|
_currentLogFileHandle = nil;
|
|
|
|
_currentLogFileInfo.isArchived = YES;
|
|
NSString *archivedFilePath = [_currentLogFileInfo.filePath copy];
|
|
_currentLogFileInfo = nil;
|
|
|
|
if ([_logFileManager respondsToSelector:@selector(didRollAndArchiveLogFile:)]) {
|
|
dispatch_async(_completionQueue, ^{
|
|
[self->_logFileManager didRollAndArchiveLogFile:archivedFilePath];
|
|
});
|
|
}
|
|
|
|
if (_currentLogFileVnode) {
|
|
dispatch_source_cancel(_currentLogFileVnode);
|
|
_currentLogFileVnode = nil;
|
|
}
|
|
|
|
if (_rollingTimer) {
|
|
dispatch_source_cancel(_rollingTimer);
|
|
_rollingTimer = nil;
|
|
}
|
|
}
|
|
|
|
- (void)lt_maybeRollLogFileDueToAge {
|
|
NSAssert([self isOnInternalLoggerQueue], @"lt_ methods should be on logger queue.");
|
|
|
|
if (_rollingFrequency > 0.0 && _currentLogFileInfo.age >= _rollingFrequency) {
|
|
NSLogVerbose(@"DDFileLogger: Rolling log file due to age...");
|
|
[self lt_rollLogFileNow];
|
|
} else {
|
|
[self lt_scheduleTimerToRollLogFileDueToAge];
|
|
}
|
|
}
|
|
|
|
- (void)lt_maybeRollLogFileDueToSize {
|
|
NSAssert([self isOnInternalLoggerQueue], @"lt_ methods should be on logger queue.");
|
|
|
|
// 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 lt_rollLogFileNow];
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#pragma mark File Logging
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
- (BOOL)lt_shouldLogFileBeArchived:(DDLogFileInfo *)mostRecentLogFileInfo {
|
|
NSAssert([self isOnInternalLoggerQueue], @"lt_ methods should be on logger queue.");
|
|
|
|
if (mostRecentLogFileInfo.isArchived) {
|
|
return NO;
|
|
} else if ([self shouldArchiveRecentLogFileInfo:mostRecentLogFileInfo]) {
|
|
return YES;
|
|
} else if (_maximumFileSize > 0 && mostRecentLogFileInfo.fileSize >= _maximumFileSize) {
|
|
return YES;
|
|
} else if (_rollingFrequency > 0.0 && mostRecentLogFileInfo.age >= _rollingFrequency) {
|
|
return 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 user has overwritten to NSFileProtectionNone there is no neeed to create a new one.
|
|
if (doesAppRunInBackground()) {
|
|
NSFileProtectionType key = mostRecentLogFileInfo.fileAttributes[NSFileProtectionKey];
|
|
BOOL isUntilFirstAuth = [key isEqualToString:NSFileProtectionCompleteUntilFirstUserAuthentication];
|
|
BOOL isNone = [key isEqualToString:NSFileProtectionNone];
|
|
|
|
if (!isUntilFirstAuth && !isNone) {
|
|
return YES;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return NO;
|
|
}
|
|
|
|
/**
|
|
* Returns the log file that should be used.
|
|
* If there is an existing log file that is suitable, within the
|
|
* constraints of maximumFileSize and rollingFrequency, then it is returned.
|
|
*
|
|
* Otherwise a new file is created and returned.
|
|
**/
|
|
- (DDLogFileInfo *)currentLogFileInfo {
|
|
// The design of this method is taken from the DDAbstractLogger implementation.
|
|
// For extensive documentation please refer to the DDAbstractLogger implementation.
|
|
// Do not access this method on any Lumberjack queue, will deadlock.
|
|
|
|
NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
|
|
NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
|
|
|
|
__block DDLogFileInfo *info = nil;
|
|
dispatch_block_t block = ^{
|
|
info = [self lt_currentLogFileInfo];
|
|
};
|
|
|
|
dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
|
|
|
|
dispatch_sync(globalLoggingQueue, ^{
|
|
dispatch_sync(self->_loggerQueue, block);
|
|
});
|
|
|
|
return info;
|
|
}
|
|
|
|
- (DDLogFileInfo *)lt_currentLogFileInfo {
|
|
NSAssert([self isOnInternalLoggerQueue], @"lt_ methods should be on logger queue.");
|
|
|
|
// Get the current log file info ivar (might be nil).
|
|
DDLogFileInfo *newCurrentLogFile = _currentLogFileInfo;
|
|
|
|
// Check if we're resuming and if so, get the first of the sorted log file infos.
|
|
BOOL isResuming = newCurrentLogFile == nil;
|
|
if (isResuming) {
|
|
NSArray *sortedLogFileInfos = [_logFileManager sortedLogFileInfos];
|
|
newCurrentLogFile = sortedLogFileInfos.firstObject;
|
|
}
|
|
|
|
// Check if the file we've found is still valid. Otherwise create a new one.
|
|
if (newCurrentLogFile != nil && [self lt_shouldUseLogFile:newCurrentLogFile isResuming:isResuming]) {
|
|
if (isResuming) {
|
|
NSLogVerbose(@"DDFileLogger: Resuming logging with file %@", newCurrentLogFile.fileName);
|
|
}
|
|
_currentLogFileInfo = newCurrentLogFile;
|
|
} else {
|
|
NSString *currentLogFilePath = [_logFileManager createNewLogFile];
|
|
_currentLogFileInfo = [[DDLogFileInfo alloc] initWithFilePath:currentLogFilePath];
|
|
}
|
|
|
|
return _currentLogFileInfo;
|
|
}
|
|
|
|
- (BOOL)lt_shouldUseLogFile:(nonnull DDLogFileInfo *)logFileInfo isResuming:(BOOL)isResuming {
|
|
NSAssert([self isOnInternalLoggerQueue], @"lt_ methods should be on logger queue.");
|
|
NSParameterAssert(logFileInfo);
|
|
|
|
// Check if the log file is archived. We must not use archived log files.
|
|
if (logFileInfo.isArchived) {
|
|
return NO;
|
|
}
|
|
|
|
// If we're resuming, we need to check if the log file is allowed for reuse or needs to be archived.
|
|
if (isResuming && (_doNotReuseLogFiles || [self lt_shouldLogFileBeArchived:logFileInfo])) {
|
|
logFileInfo.isArchived = YES;
|
|
NSString *archivedLogFilePath = [logFileInfo.fileName copy];
|
|
|
|
if ([_logFileManager respondsToSelector:@selector(didArchiveLogFile:)]) {
|
|
dispatch_async(_completionQueue, ^{
|
|
[self->_logFileManager didArchiveLogFile:archivedLogFilePath];
|
|
});
|
|
}
|
|
|
|
return NO;
|
|
}
|
|
|
|
// All checks have passed. It's valid.
|
|
return YES;
|
|
}
|
|
|
|
- (void)lt_monitorCurrentLogFileForExternalChanges {
|
|
NSAssert([self isOnInternalLoggerQueue], @"lt_ methods should be on logger queue.");
|
|
NSAssert(_currentLogFileHandle, @"Can not monitor without handle.");
|
|
|
|
dispatch_source_vnode_flags_t flags = DISPATCH_VNODE_DELETE | DISPATCH_VNODE_RENAME | DISPATCH_VNODE_REVOKE;
|
|
_currentLogFileVnode = dispatch_source_create(DISPATCH_SOURCE_TYPE_VNODE,
|
|
(uintptr_t)[_currentLogFileHandle fileDescriptor],
|
|
flags,
|
|
_loggerQueue);
|
|
|
|
__weak __auto_type weakSelf = self;
|
|
dispatch_source_set_event_handler(_currentLogFileVnode, ^{ @autoreleasepool {
|
|
NSLogInfo(@"DDFileLogger: Current logfile was moved. Rolling it and creating a new one");
|
|
[weakSelf lt_rollLogFileNow];
|
|
} });
|
|
|
|
#if !OS_OBJECT_USE_OBJC
|
|
dispatch_source_t vnode = _currentLogFileVnode;
|
|
dispatch_source_set_cancel_handler(_currentLogFileVnode, ^{
|
|
dispatch_release(vnode);
|
|
});
|
|
#endif
|
|
|
|
dispatch_resume(_currentLogFileVnode);
|
|
}
|
|
|
|
- (NSFileHandle *)lt_currentLogFileHandle {
|
|
NSAssert([self isOnInternalLoggerQueue], @"lt_ methods should be on logger queue.");
|
|
|
|
if (!_currentLogFileHandle) {
|
|
NSString *logFilePath = [[self lt_currentLogFileInfo] filePath];
|
|
_currentLogFileHandle = [NSFileHandle fileHandleForWritingAtPath:logFilePath];
|
|
[_currentLogFileHandle seekToEndOfFile];
|
|
|
|
if (_currentLogFileHandle) {
|
|
[self lt_scheduleTimerToRollLogFileDueToAge];
|
|
[self lt_monitorCurrentLogFileForExternalChanges];
|
|
}
|
|
}
|
|
|
|
return _currentLogFileHandle;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#pragma mark DDLogger Protocol
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
static int exception_count = 0;
|
|
|
|
- (void)logMessage:(DDLogMessage *)logMessage {
|
|
NSAssert([self isOnInternalLoggerQueue], @"logMessage should only be executed on internal queue.");
|
|
|
|
NSString *message = logMessage->_message;
|
|
BOOL isFormatted = NO;
|
|
|
|
if (_logFormatter != nil) {
|
|
message = [_logFormatter formatLogMessage:logMessage];
|
|
isFormatted = message != logMessage->_message;
|
|
}
|
|
|
|
if (message.length == 0) {
|
|
return;
|
|
}
|
|
|
|
BOOL shouldFormat = !isFormatted || _automaticallyAppendNewlineForCustomFormatters;
|
|
if (shouldFormat && ![message hasSuffix:@"\n"]) {
|
|
message = [message stringByAppendingString:@"\n"];
|
|
}
|
|
|
|
[self lt_logData:[message dataUsingEncoding:NSUTF8StringEncoding]];
|
|
}
|
|
|
|
- (void)willLogMessage {
|
|
|
|
}
|
|
|
|
- (void)didLogMessage {
|
|
[self lt_maybeRollLogFileDueToSize];
|
|
}
|
|
|
|
- (BOOL)shouldArchiveRecentLogFileInfo:(__unused DDLogFileInfo *)recentLogFileInfo {
|
|
return NO;
|
|
}
|
|
|
|
- (void)willRemoveLogger {
|
|
[self lt_rollLogFileNow];
|
|
}
|
|
|
|
- (void)flush {
|
|
// This method is public.
|
|
// We need to execute the rolling on our logging thread/queue.
|
|
|
|
dispatch_block_t block = ^{
|
|
@autoreleasepool {
|
|
[self lt_flush];
|
|
}
|
|
};
|
|
|
|
// 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_sync(globalLoggingQueue, ^{
|
|
dispatch_sync(self.loggerQueue, block);
|
|
});
|
|
}
|
|
}
|
|
|
|
- (void)lt_flush {
|
|
NSAssert([self isOnInternalLoggerQueue], @"flush should only be executed on internal queue.");
|
|
[_currentLogFileHandle synchronizeFile];
|
|
}
|
|
|
|
- (DDLoggerName)loggerName {
|
|
return DDLoggerNameFile;
|
|
}
|
|
|
|
@end
|
|
|
|
@implementation DDFileLogger (Internal)
|
|
|
|
- (void)logData:(NSData *)data {
|
|
// This method is public.
|
|
// We need to execute the rolling on our logging thread/queue.
|
|
|
|
dispatch_block_t block = ^{
|
|
@autoreleasepool {
|
|
[self lt_logData:data];
|
|
}
|
|
};
|
|
|
|
// 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_sync(globalLoggingQueue, ^{
|
|
dispatch_sync(self.loggerQueue, block);
|
|
});
|
|
}
|
|
}
|
|
|
|
- (void)lt_logData:(NSData *)data {
|
|
NSAssert([self isOnInternalLoggerQueue], @"logMessage should only be executed on internal queue.");
|
|
|
|
if (data.length == 0) {
|
|
return;
|
|
}
|
|
|
|
@try {
|
|
[self willLogMessage];
|
|
|
|
NSFileHandle *handle = [self lt_currentLogFileHandle];
|
|
[handle seekToEndOfFile];
|
|
[handle writeData:data];
|
|
|
|
[self didLogMessage];
|
|
} @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.");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
- (NSData *)lt_dataForMessage:(DDLogMessage *)logMessage {
|
|
NSAssert([self isOnInternalLoggerQueue], @"logMessage should only be executed on internal queue.");
|
|
|
|
NSString *message = logMessage->_message;
|
|
BOOL isFormatted = NO;
|
|
|
|
if (_logFormatter != nil) {
|
|
message = [_logFormatter formatLogMessage:logMessage];
|
|
isFormatted = message != logMessage->_message;
|
|
}
|
|
|
|
if (message.length == 0) {
|
|
return [NSData new];
|
|
}
|
|
|
|
BOOL shouldFormat = !isFormatted || _automaticallyAppendNewlineForCustomFormatters;
|
|
if (shouldFormat && ![message hasSuffix:@"\n"]) {
|
|
message = [message stringByAppendingString:@"\n"];
|
|
}
|
|
|
|
return [message dataUsingEncoding:NSUTF8StringEncoding];
|
|
}
|
|
|
|
@end
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#pragma mark -
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#if TARGET_IPHONE_SIMULATOR
|
|
static NSString * const kDDXAttrArchivedName = @"archived";
|
|
#else
|
|
static NSString * const kDDXAttrArchivedName = @"lumberjack.log.archived";
|
|
#endif
|
|
|
|
@interface DDLogFileInfo () {
|
|
__strong NSString *_filePath;
|
|
__strong NSString *_fileName;
|
|
|
|
__strong NSDictionary *_fileAttributes;
|
|
|
|
__strong NSDate *_creationDate;
|
|
__strong NSDate *_modificationDate;
|
|
|
|
unsigned long long _fileSize;
|
|
}
|
|
|
|
@end
|
|
|
|
|
|
@implementation DDLogFileInfo
|
|
|
|
@synthesize filePath;
|
|
|
|
@dynamic fileName;
|
|
@dynamic fileAttributes;
|
|
@dynamic creationDate;
|
|
@dynamic modificationDate;
|
|
@dynamic fileSize;
|
|
@dynamic age;
|
|
|
|
@dynamic isArchived;
|
|
|
|
|
|
#pragma mark Lifecycle
|
|
|
|
+ (instancetype)logFileWithPath:(NSString *)aFilePath {
|
|
return [[self alloc] initWithFilePath:aFilePath];
|
|
}
|
|
|
|
- (instancetype)initWithFilePath:(NSString *)aFilePath {
|
|
if ((self = [super init])) {
|
|
filePath = [aFilePath copy];
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#pragma mark Standard Info
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
- (NSDictionary *)fileAttributes {
|
|
if (_fileAttributes == nil && filePath != nil) {
|
|
NSError *error = nil;
|
|
_fileAttributes = [[NSFileManager defaultManager] attributesOfItemAtPath:filePath error:&error];
|
|
|
|
if (error) {
|
|
NSLogError(@"DDLogFileInfo: Failed to read file attributes: %@", error);
|
|
}
|
|
}
|
|
|
|
return _fileAttributes ?: @{};
|
|
}
|
|
|
|
- (NSString *)fileName {
|
|
if (_fileName == nil) {
|
|
_fileName = [filePath lastPathComponent];
|
|
}
|
|
|
|
return _fileName;
|
|
}
|
|
|
|
- (NSDate *)modificationDate {
|
|
if (_modificationDate == nil) {
|
|
_modificationDate = self.fileAttributes[NSFileModificationDate];
|
|
}
|
|
|
|
return _modificationDate;
|
|
}
|
|
|
|
- (NSDate *)creationDate {
|
|
if (_creationDate == nil) {
|
|
_creationDate = self.fileAttributes[NSFileCreationDate];
|
|
}
|
|
|
|
return _creationDate;
|
|
}
|
|
|
|
- (unsigned long long)fileSize {
|
|
if (_fileSize == 0) {
|
|
_fileSize = [self.fileAttributes[NSFileSize] unsignedLongLongValue];
|
|
}
|
|
|
|
return _fileSize;
|
|
}
|
|
|
|
- (NSTimeInterval)age {
|
|
return -[[self creationDate] timeIntervalSinceNow];
|
|
}
|
|
|
|
- (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];
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#pragma mark Archiving
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
- (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:kDDXAttrArchivedName];
|
|
|
|
#else
|
|
|
|
return [self hasExtendedAttributeWithName:kDDXAttrArchivedName];
|
|
|
|
#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:kDDXAttrArchivedName];
|
|
} else {
|
|
[self removeExtensionAttributeWithName:kDDXAttrArchivedName];
|
|
}
|
|
|
|
#else
|
|
|
|
if (flag) {
|
|
[self addExtendedAttributeWithName:kDDXAttrArchivedName];
|
|
} else {
|
|
[self removeExtendedAttributeWithName:kDDXAttrArchivedName];
|
|
}
|
|
|
|
#endif
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#pragma mark Changes
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
- (void)reset {
|
|
_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];
|
|
|
|
#ifdef DEBUG
|
|
BOOL directory = NO;
|
|
[[NSFileManager defaultManager] fileExistsAtPath:fileDir isDirectory:&directory];
|
|
NSAssert(directory, @"Containing directory must exist.");
|
|
#endif
|
|
|
|
NSError *error = nil;
|
|
|
|
BOOL success = [[NSFileManager defaultManager] removeItemAtPath:newFilePath error:&error];
|
|
if (!success && error.code != NSFileNoSuchFileError) {
|
|
NSLogError(@"DDLogFileInfo: Error deleting archive (%@): %@", self.fileName, error);
|
|
}
|
|
|
|
success = [[NSFileManager defaultManager] moveItemAtPath:filePath toPath:newFilePath error:&error];
|
|
|
|
// When a log file is deleted, moved or renamed on the simulator, we attempt to rename it as a
|
|
// result of "archiving" it, but since the file doesn't exist anymore, needless error logs are printed
|
|
// We therefore ignore this error, and assert that the directory we are copying into exists (which
|
|
// is the only other case where this error code can come up).
|
|
#if TARGET_IPHONE_SIMULATOR
|
|
if (!success && error.code != NSFileNoSuchFileError) {
|
|
#else
|
|
if (!success) {
|
|
#endif
|
|
NSLogError(@"DDLogFileInfo: Error renaming file (%@): %@", self.fileName, error);
|
|
}
|
|
|
|
filePath = newFilePath;
|
|
[self reset];
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#pragma mark Attribute Management
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#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.
|
|
|
|
- (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. 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[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"
|
|
//
|
|
// "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.firstObject];
|
|
}
|
|
|
|
NSString *lastExt = @"";
|
|
|
|
NSUInteger i;
|
|
|
|
for (i = 1; i < count; i++) {
|
|
NSString *attr = components[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"
|
|
//
|
|
// "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.firstObject];
|
|
}
|
|
|
|
BOOL found = NO;
|
|
|
|
NSUInteger i;
|
|
|
|
for (i = 1; i < count; i++) {
|
|
NSString *attr = components[i];
|
|
|
|
if ([attrName isEqualToString:attr]) {
|
|
found = YES;
|
|
} else {
|
|
[newFileName appendFormat:@".%@", attr];
|
|
}
|
|
}
|
|
|
|
if (found) {
|
|
[self renameFile:newFileName];
|
|
}
|
|
}
|
|
|
|
#else /* if TARGET_IPHONE_SIMULATOR */
|
|
|
|
- (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);
|
|
}
|
|
|
|
- (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 = %s",
|
|
attrName,
|
|
filePath,
|
|
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 = %s",
|
|
attrName,
|
|
self.fileName,
|
|
strerror(errno));
|
|
}
|
|
}
|
|
|
|
#endif /* if TARGET_IPHONE_SIMULATOR */
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#pragma mark Comparisons
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
- (BOOL)isEqual:(id)object {
|
|
if ([object isKindOfClass:[self class]]) {
|
|
DDLogFileInfo *another = (DDLogFileInfo *)object;
|
|
|
|
return [filePath isEqualToString:[another filePath]];
|
|
}
|
|
|
|
return NO;
|
|
}
|
|
|
|
- (NSUInteger)hash {
|
|
return [filePath hash];
|
|
}
|
|
|
|
- (NSComparisonResult)reverseCompareByCreationDate:(DDLogFileInfo *)another {
|
|
__auto_type us = [self creationDate];
|
|
__auto_type them = [another creationDate];
|
|
return [them compare:us];
|
|
}
|
|
|
|
- (NSComparisonResult)reverseCompareByModificationDate:(DDLogFileInfo *)another {
|
|
__auto_type us = [self modificationDate];
|
|
__auto_type them = [another modificationDate];
|
|
return [them compare:us];
|
|
}
|
|
|
|
@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
|