motion-yapper 0.0.1 → 0.0.2

data/vendor/Pods/CocoaLumberjack/Lumberjack/DDLog+LOGV.h

@@ -0,0 +1,99 @@
+//
+//  DDLog+LOGV.h
+//  Lumberjack
+//
+//  Created by Mike Pontillo on 11/20/12.
+//
+//
+
+#ifndef Lumberjack_DDLog_LOGV_h
+#define Lumberjack_DDLog_LOGV_h
+
+#import "DDLog.h"
+
+
+#define LOGV_MACRO(isAsynchronous, lvl, flg, ctx, atag, fnct, frmt, avalist) \
+  [DDLog log:isAsynchronous                                                  \
+       level:lvl                                                             \
+        flag:flg                                                             \
+     context:ctx                                                             \
+        file:__FILE__                                                        \
+    function:fnct                                                            \
+        line:__LINE__                                                        \
+         tag:atag                                                            \
+      format:frmt                                                            \
+        args:avalist]
+
+#define LOGV_OBJC_MACRO(async, lvl, flg, ctx, frmt, avalist) \
+             LOGV_MACRO(async, lvl, flg, ctx, nil, sel_getName(_cmd), frmt, avalist)
+
+#define LOGV_C_MACRO(async, lvl, flg, ctx, frmt, avalist) \
+          LOGV_MACRO(async, lvl, flg, ctx, nil, __FUNCTION__, frmt, avalist)
+
+
+
+#define  SYNC_LOGV_OBJC_MACRO(lvl, flg, ctx, frmt, avalist) \
+              LOGV_OBJC_MACRO( NO, lvl, flg, ctx, frmt, avalist)
+
+#define ASYNC_LOGV_OBJC_MACRO(lvl, flg, ctx, frmt, avalist) \
+              LOGV_OBJC_MACRO(YES, lvl, flg, ctx, frmt, avalist)
+
+#define  SYNC_LOGV_C_MACRO(lvl, flg, ctx, frmt, avalist) \
+              LOGV_C_MACRO( NO, lvl, flg, ctx, frmt, avalist)
+
+#define ASYNC_LOGV_C_MACRO(lvl, flg, ctx, frmt, avalist) \
+              LOGV_C_MACRO(YES, lvl, flg, ctx, frmt, avalist)
+
+
+
+#define LOGV_MAYBE(async, lvl, flg, ctx, fnct, frmt, avalist) \
+  do { if(lvl & flg) LOGV_MACRO(async, lvl, flg, ctx, nil, fnct, frmt, avalist); } while(0)
+
+#define LOGV_OBJC_MAYBE(async, lvl, flg, ctx, frmt, avalist) \
+             LOGV_MAYBE(async, lvl, flg, ctx, sel_getName(_cmd), frmt, avalist)
+
+#define LOGV_C_MAYBE(async, lvl, flg, ctx, frmt, avalist) \
+          LOGV_MAYBE(async, lvl, flg, ctx, __FUNCTION__, frmt, avalist)
+
+#define  SYNC_LOGV_OBJC_MAYBE(lvl, flg, ctx, frmt, avalist) \
+              LOGV_OBJC_MAYBE( NO, lvl, flg, ctx, frmt, avalist)
+
+#define ASYNC_LOGV_OBJC_MAYBE(lvl, flg, ctx, frmt, avalist) \
+              LOGV_OBJC_MAYBE(YES, lvl, flg, ctx, frmt, avalist)
+
+#define  SYNC_LOGV_C_MAYBE(lvl, flg, ctx, frmt, avalist) \
+              LOGV_C_MAYBE( NO, lvl, flg, ctx, frmt, avalist)
+
+#define ASYNC_LOGV_C_MAYBE(lvl, flg, ctx, frmt, avalist) \
+              LOGV_C_MAYBE(YES, lvl, flg, ctx, frmt, avalist)
+
+
+
+#define LOGV_OBJC_TAG_MACRO(async, lvl, flg, ctx, tag, frmt, avalist) \
+                 LOGV_MACRO(async, lvl, flg, ctx, tag, sel_getName(_cmd), frmt, avalist)
+
+#define LOGV_C_TAG_MACRO(async, lvl, flg, ctx, tag, frmt, avalist) \
+              LOGV_MACRO(async, lvl, flg, ctx, tag, __FUNCTION__, frmt, avalist)
+
+#define LOGV_TAG_MAYBE(async, lvl, flg, ctx, tag, fnct, frmt, avalist) \
+  do { if(lvl & flg) LOGV_MACRO(async, lvl, flg, ctx, tag, fnct, frmt, avalist); } while(0)
+
+#define LOGV_OBJC_TAG_MAYBE(async, lvl, flg, ctx, tag, frmt, avalist) \
+             LOGV_TAG_MAYBE(async, lvl, flg, ctx, tag, sel_getName(_cmd), frmt, avalist)
+
+#define LOGV_C_TAG_MAYBE(async, lvl, flg, ctx, tag, frmt, avalist) \
+          LOGV_TAG_MAYBE(async, lvl, flg, ctx, tag, __FUNCTION__, frmt, avalist)
+
+
+
+#define DDLogvError(frmt, avalist)   LOGV_OBJC_MAYBE(LOG_ASYNC_ERROR,   ddLogLevel, LOG_FLAG_ERROR,   0, frmt, avalist)
+#define DDLogvWarn(frmt, avalist)    LOGV_OBJC_MAYBE(LOG_ASYNC_WARN,    ddLogLevel, LOG_FLAG_WARN,    0, frmt, avalist)
+#define DDLogvInfo(frmt, avalist)    LOGV_OBJC_MAYBE(LOG_ASYNC_INFO,    ddLogLevel, LOG_FLAG_INFO,    0, frmt, avalist)
+#define DDLogvVerbose(frmt, avalist) LOGV_OBJC_MAYBE(LOG_ASYNC_VERBOSE, ddLogLevel, LOG_FLAG_VERBOSE, 0, frmt, avalist)
+
+#define DDLogvCError(frmt, avalist)   LOGV_C_MAYBE(LOG_ASYNC_ERROR,   ddLogLevel, LOG_FLAG_ERROR,   0, frmt, avalist)
+#define DDLogvCWarn(frmt, avalist)    LOGV_C_MAYBE(LOG_ASYNC_WARN,    ddLogLevel, LOG_FLAG_WARN,    0, frmt, avalist)
+#define DDLogvCInfo(frmt, avalist)    LOGV_C_MAYBE(LOG_ASYNC_INFO,    ddLogLevel, LOG_FLAG_INFO,    0, frmt, avalist)
+#define DDLogvCVerbose(frmt, avalist) LOGV_C_MAYBE(LOG_ASYNC_VERBOSE, ddLogLevel, LOG_FLAG_VERBOSE, 0, frmt, avalist)
+
+#endif

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

@@ -4,10 +4,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
  * 
  * Otherwise, here is a quick refresher.
  * There are three steps to using the macros:
@@ -23,6 +23,18 @@
  * // Log levels: off, error, warn, info, verbose
  * static const int ddLogLevel = LOG_LEVEL_VERBOSE;
  * 
+ * Step 2 [3rd party frameworks]:
+ *
+ * Define your LOG_LEVEL_DEF to a different variable/function than ddLogLevel:
+ *
+ * // #undef LOG_LEVEL_DEF // Undefine first only if needed
+ * #define LOG_LEVEL_DEF myLibLogLevel
+ *
+ * Define your logging level in your implementation file:
+ *
+ * // Log levels: off, error, warn, info, verbose
+ * static const int myLibLogLevel = LOG_LEVEL_VERBOSE;
+ *
  * Step 3:
  * Replace your NSLog statements with DDLog statements according to the severity of the message.
  * 
@@ -32,6 +44,9 @@
  * This means you can pass it multiple variables just like NSLog.
 **/
 
+#ifndef LOG_LEVEL_DEF
+    #define LOG_LEVEL_DEF ddLogLevel
+#endif
 
 @class DDLogMessage;
 
@@ -85,6 +100,8 @@
  * 
  * if (logFlagForThisLogMsg & ddLogLevel) { execute log message }
  * 
+ * When LOG_LEVEL_DEF is defined as ddLogLevel.
+ *
  * As shown further below, Lumberjack actually uses a bitmask as opposed to primitive log levels.
  * This allows for a great amount of flexibility and some pretty advanced fine grained logging techniques.
  * 
@@ -151,11 +168,11 @@
  * 
  * More advanced users may choose to completely customize the levels (and level names) to suite their needs.
  * For more information on this see the "Custom Log Levels" page:
- * https://github.com/robbiehanson/CocoaLumberjack/wiki/CustomLogLevels
+ * https://github.com/CocoaLumberjack/CocoaLumberjack/wiki/CustomLogLevels
  * 
  * Advanced users may also notice that we're using a bitmask.
  * This is to allow for custom fine grained logging:
- * https://github.com/robbiehanson/CocoaLumberjack/wiki/FineGrainedLogging
+ * https://github.com/CocoaLumberjack/CocoaLumberjack/wiki/FineGrainedLogging
  * 
  * -- Flags --
  * 
@@ -166,6 +183,8 @@
  * 
  * static const int ddLogLevel = LOG_FLAG_ERROR | LOG_FLAG_INFO;
  * 
+ * When LOG_LEVEL_DEF is defined as ddLogLevel.
+ *
  * Flags may also be consulted when writing custom log formatters,
  * as the DDLogMessage class captures the individual flag that caused the log message to fire.
  * 
@@ -202,41 +221,47 @@
  * Instead, create your own MyLogging.h or ApplicationNameLogging.h or CompanyLogging.h
  * 
  * For an example of customizing your logging experience, see the "Custom Log Levels" page:
- * https://github.com/robbiehanson/CocoaLumberjack/wiki/CustomLogLevels
+ * https://github.com/CocoaLumberjack/CocoaLumberjack/wiki/CustomLogLevels
 **/
 
-#define LOG_FLAG_ERROR    (1 << 0)  // 0...0001
-#define LOG_FLAG_WARN     (1 << 1)  // 0...0010
-#define LOG_FLAG_INFO     (1 << 2)  // 0...0100
-#define LOG_FLAG_VERBOSE  (1 << 3)  // 0...1000
+#define LOG_FLAG_ERROR    (1 << 0)  // 0...00001
+#define LOG_FLAG_WARN     (1 << 1)  // 0...00010
+#define LOG_FLAG_INFO     (1 << 2)  // 0...00100
+#define LOG_FLAG_DEBUG    (1 << 3)  // 0...01000
+#define LOG_FLAG_VERBOSE  (1 << 4)  // 0...10000
 
 #define LOG_LEVEL_OFF     0
-#define LOG_LEVEL_ERROR   (LOG_FLAG_ERROR)                                                    // 0...0001
-#define LOG_LEVEL_WARN    (LOG_FLAG_ERROR | LOG_FLAG_WARN)                                    // 0...0011
-#define LOG_LEVEL_INFO    (LOG_FLAG_ERROR | LOG_FLAG_WARN | LOG_FLAG_INFO)                    // 0...0111
-#define LOG_LEVEL_VERBOSE (LOG_FLAG_ERROR | LOG_FLAG_WARN | LOG_FLAG_INFO | LOG_FLAG_VERBOSE) // 0...1111
-
-#define LOG_ERROR   (ddLogLevel & LOG_FLAG_ERROR)
-#define LOG_WARN    (ddLogLevel & LOG_FLAG_WARN)
-#define LOG_INFO    (ddLogLevel & LOG_FLAG_INFO)
-#define LOG_VERBOSE (ddLogLevel & LOG_FLAG_VERBOSE)
+#define LOG_LEVEL_ERROR   (LOG_FLAG_ERROR)                                                                          // 0...00001
+#define LOG_LEVEL_WARN    (LOG_FLAG_ERROR | LOG_FLAG_WARN)                                                          // 0...00011
+#define LOG_LEVEL_INFO    (LOG_FLAG_ERROR | LOG_FLAG_WARN | LOG_FLAG_INFO)                                          // 0...00111
+#define LOG_LEVEL_DEBUG   (LOG_FLAG_ERROR | LOG_FLAG_WARN | LOG_FLAG_INFO | LOG_FLAG_DEBUG)                         // 0...01111
+#define LOG_LEVEL_VERBOSE (LOG_FLAG_ERROR | LOG_FLAG_WARN | LOG_FLAG_INFO | LOG_FLAG_DEBUG | LOG_FLAG_VERBOSE)      // 0...11111
+
+#define LOG_ERROR    (LOG_LEVEL_DEF & LOG_FLAG_ERROR)
+#define LOG_WARN     (LOG_LEVEL_DEF & LOG_FLAG_WARN)
+#define LOG_INFO     (LOG_LEVEL_DEF & LOG_FLAG_INFO)
+#define LOG_DEBUG    (LOG_LEVEL_DEF & LOG_FLAG_DEBUG)
+#define LOG_VERBOSE  (LOG_LEVEL_DEF & LOG_FLAG_VERBOSE)
 
 #define LOG_ASYNC_ENABLED YES
 
-#define LOG_ASYNC_ERROR   ( NO && LOG_ASYNC_ENABLED)
-#define LOG_ASYNC_WARN    (YES && LOG_ASYNC_ENABLED)
-#define LOG_ASYNC_INFO    (YES && LOG_ASYNC_ENABLED)
-#define LOG_ASYNC_VERBOSE (YES && LOG_ASYNC_ENABLED)
+#define LOG_ASYNC_ERROR    ( NO && LOG_ASYNC_ENABLED)
+#define LOG_ASYNC_WARN     (YES && LOG_ASYNC_ENABLED)
+#define LOG_ASYNC_INFO     (YES && LOG_ASYNC_ENABLED)
+#define LOG_ASYNC_DEBUG    (YES && LOG_ASYNC_ENABLED)
+#define LOG_ASYNC_VERBOSE  (YES && LOG_ASYNC_ENABLED)
 
-#define DDLogError(frmt, ...)   LOG_OBJC_MAYBE(LOG_ASYNC_ERROR,   ddLogLevel, LOG_FLAG_ERROR,   0, frmt, ##__VA_ARGS__)
-#define DDLogWarn(frmt, ...)    LOG_OBJC_MAYBE(LOG_ASYNC_WARN,    ddLogLevel, LOG_FLAG_WARN,    0, frmt, ##__VA_ARGS__)
-#define DDLogInfo(frmt, ...)    LOG_OBJC_MAYBE(LOG_ASYNC_INFO,    ddLogLevel, LOG_FLAG_INFO,    0, frmt, ##__VA_ARGS__)
-#define DDLogVerbose(frmt, ...) LOG_OBJC_MAYBE(LOG_ASYNC_VERBOSE, ddLogLevel, LOG_FLAG_VERBOSE, 0, frmt, ##__VA_ARGS__)
+#define DDLogError(frmt, ...)   LOG_OBJC_MAYBE(LOG_ASYNC_ERROR,   LOG_LEVEL_DEF, LOG_FLAG_ERROR,   0, frmt, ##__VA_ARGS__)
+#define DDLogWarn(frmt, ...)    LOG_OBJC_MAYBE(LOG_ASYNC_WARN,    LOG_LEVEL_DEF, LOG_FLAG_WARN,    0, frmt, ##__VA_ARGS__)
+#define DDLogInfo(frmt, ...)    LOG_OBJC_MAYBE(LOG_ASYNC_INFO,    LOG_LEVEL_DEF, LOG_FLAG_INFO,    0, frmt, ##__VA_ARGS__)
+#define DDLogDebug(frmt, ...)   LOG_OBJC_MAYBE(LOG_ASYNC_DEBUG,   LOG_LEVEL_DEF, LOG_FLAG_DEBUG,   0, frmt, ##__VA_ARGS__)
+#define DDLogVerbose(frmt, ...) LOG_OBJC_MAYBE(LOG_ASYNC_VERBOSE, LOG_LEVEL_DEF, LOG_FLAG_VERBOSE, 0, frmt, ##__VA_ARGS__)
 
-#define DDLogCError(frmt, ...)   LOG_C_MAYBE(LOG_ASYNC_ERROR,   ddLogLevel, LOG_FLAG_ERROR,   0, frmt, ##__VA_ARGS__)
-#define DDLogCWarn(frmt, ...)    LOG_C_MAYBE(LOG_ASYNC_WARN,    ddLogLevel, LOG_FLAG_WARN,    0, frmt, ##__VA_ARGS__)
-#define DDLogCInfo(frmt, ...)    LOG_C_MAYBE(LOG_ASYNC_INFO,    ddLogLevel, LOG_FLAG_INFO,    0, frmt, ##__VA_ARGS__)
-#define DDLogCVerbose(frmt, ...) LOG_C_MAYBE(LOG_ASYNC_VERBOSE, ddLogLevel, LOG_FLAG_VERBOSE, 0, frmt, ##__VA_ARGS__)
+#define DDLogCError(frmt, ...)   LOG_C_MAYBE(LOG_ASYNC_ERROR,   LOG_LEVEL_DEF, LOG_FLAG_ERROR,   0, frmt, ##__VA_ARGS__)
+#define DDLogCWarn(frmt, ...)    LOG_C_MAYBE(LOG_ASYNC_WARN,    LOG_LEVEL_DEF, LOG_FLAG_WARN,    0, frmt, ##__VA_ARGS__)
+#define DDLogCInfo(frmt, ...)    LOG_C_MAYBE(LOG_ASYNC_INFO,    LOG_LEVEL_DEF, LOG_FLAG_INFO,    0, frmt, ##__VA_ARGS__)
+#define DDLogCDebug(frmt, ...)   LOG_C_MAYBE(LOG_ASYNC_DEBUG,   LOG_LEVEL_DEF, LOG_FLAG_DEBUG,   0, frmt, ##__VA_ARGS__)
+#define DDLogCVerbose(frmt, ...) LOG_C_MAYBE(LOG_ASYNC_VERBOSE, LOG_LEVEL_DEF, LOG_FLAG_VERBOSE, 0, frmt, ##__VA_ARGS__)
 
 /**
  * The THIS_FILE macro gives you an NSString of the file name.
@@ -323,11 +348,19 @@ NSString *DDExtractFileNameWithoutExtension(const char *filePath, BOOL copy);
  * you should create and add a logger.
 **/
 
-+ (void)addLogger:(id <DDLogger>)logger;
-+ (void)removeLogger:(id <DDLogger>)logger;
++ (void)addLogger:(id <DDLogger>)logger;    // adds the logger using maximum log level (LOG_LEVEL_VERBOSE)
+
+/**
+ * Please use as logLevels the LOG_LEVEL_* macros
+ *
+**/
++ (void)addLogger:(id <DDLogger>)logger withLogLevel:(int)logLevel;
 
++ (void)removeLogger:(id <DDLogger>)logger;
 + (void)removeAllLoggers;
 
++ (NSArray *)allLoggers;
+
 /**
  * Registered Dynamic Logging
  * 
@@ -422,7 +455,7 @@ NSString *DDExtractFileNameWithoutExtension(const char *filePath, BOOL copy);
  * For example, log messages for log files may be formatted differently than log messages for the console.
  * 
  * For more information about formatters, see the "Custom Formatters" page:
- * https://github.com/robbiehanson/CocoaLumberjack/wiki/CustomFormatters
+ * https://github.com/CocoaLumberjack/CocoaLumberjack/wiki/CustomFormatters
  * 
  * The formatter may also optionally filter the log message by returning nil,
  * in which case the logger will not log the message.
@@ -488,35 +521,35 @@ NSString *DDExtractFileNameWithoutExtension(const char *filePath, BOOL copy);
 **/
 
 enum {
-	DDLogMessageCopyFile     = 1 << 0,
-	DDLogMessageCopyFunction = 1 << 1
+    DDLogMessageCopyFile     = 1 << 0,
+    DDLogMessageCopyFunction = 1 << 1
 };
 typedef int DDLogMessageOptions;
 
-@interface DDLogMessage : NSObject
+@interface DDLogMessage : NSObject <NSCopying>
 {
 
 // The public variables below can be accessed directly (for speed).
 // For example: logMessage->logLevel
-	
+    
 @public
-	int logLevel;
-	int logFlag;
-	int logContext;
-	NSString *logMsg;
-	NSDate *timestamp;
-	char *file;
-	char *function;
-	int lineNumber;
-	mach_port_t machThreadID;
+    int logLevel;
+    int logFlag;
+    int logContext;
+    NSString *logMsg;
+    NSDate *timestamp;
+    char *file;
+    char *function;
+    int lineNumber;
+    mach_port_t machThreadID;
     char *queueLabel;
-	NSString *threadName;
-	
-	// For 3rd party extensions to the framework, where flags and contexts aren't enough.
-	id tag;
-	
-	// For 3rd party extensions that manually create DDLogMessage instances.
-	DDLogMessageOptions options;
+    NSString *threadName;
+    
+    // For 3rd party extensions to the framework, where flags and contexts aren't enough.
+    id tag;
+    
+    // For 3rd party extensions that manually create DDLogMessage instances.
+    DDLogMessageOptions options;
 }
 
 /**
@@ -534,15 +567,15 @@ typedef int DDLogMessageOptions;
  * However, if you need them to be copied you may use the options parameter to specify this.
  * Options is a bitmask which supports DDLogMessageCopyFile and DDLogMessageCopyFunction.
 **/
-- (id)initWithLogMsg:(NSString *)logMsg
-               level:(int)logLevel
-                flag:(int)logFlag
-             context:(int)logContext
-                file:(const char *)file
-            function:(const char *)function
-                line:(int)line
-                 tag:(id)tag
-             options:(DDLogMessageOptions)optionsMask;
+- (instancetype)initWithLogMsg:(NSString *)logMsg
+                         level:(int)logLevel
+                          flag:(int)logFlag
+                       context:(int)logContext
+                          file:(const char *)file
+                      function:(const char *)function
+                          line:(int)line
+                           tag:(id)tag
+                       options:(DDLogMessageOptions)optionsMask;
 
 /**
  * Returns the threadID as it appears in NSLog.
@@ -586,9 +619,9 @@ typedef int DDLogMessageOptions;
 
 @interface DDAbstractLogger : NSObject <DDLogger>
 {
-	id <DDLogFormatter> formatter;
-	
-	dispatch_queue_t loggerQueue;
+    id <DDLogFormatter> formatter;
+    
+    dispatch_queue_t loggerQueue;
 }
 
 - (id <DDLogFormatter>)logFormatter;

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

@@ -5,16 +5,19 @@
 #import <mach/mach_host.h>
 #import <mach/host_info.h>
 #import <libkern/OSAtomic.h>
-
+#import <Availability.h>
+#if TARGET_OS_IPHONE
+    #import <UIKit/UIDevice.h>
+#endif
 
 /**
  * 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
  * 
 **/
 
@@ -57,20 +60,24 @@ static void *const GlobalLoggingQueueIdentityKey = (void *)&GlobalLoggingQueueId
 
 @interface DDLoggerNode : NSObject {
 @public 
-	id <DDLogger> logger;	
-	dispatch_queue_t loggerQueue;
+    id <DDLogger> logger;   
+    dispatch_queue_t loggerQueue;
+    int logLevel;
 }
 
-+ (DDLoggerNode *)nodeWithLogger:(id <DDLogger>)logger loggerQueue:(dispatch_queue_t)loggerQueue;
+@property (nonatomic, assign, readonly) int logLevel;
+
++ (DDLoggerNode *)nodeWithLogger:(id <DDLogger>)logger loggerQueue:(dispatch_queue_t)loggerQueue logLevel:(int)logLevel;
 
 @end
 
 
 @interface DDLog (PrivateAPI)
 
-+ (void)lt_addLogger:(id <DDLogger>)logger;
++ (void)lt_addLogger:(id <DDLogger>)logger logLevel:(int)logLevel;
 + (void)lt_removeLogger:(id <DDLogger>)logger;
 + (void)lt_removeAllLoggers;
++ (NSArray *)lt_allLoggers;
 + (void)lt_log:(DDLogMessage *)logMessage;
 + (void)lt_flush;
 
@@ -110,51 +117,66 @@ static unsigned int numProcessors;
 **/
 + (void)initialize
 {
-	static BOOL initialized = NO;
-	if (!initialized)
-	{
-		initialized = YES;
-		
-		loggers = [[NSMutableArray alloc] initWithCapacity:4];
-		
-		NSLogDebug(@"DDLog: Using grand central dispatch");
-		
-		loggingQueue = dispatch_queue_create("cocoa.lumberjack", NULL);
-		loggingGroup = dispatch_group_create();
-		
-		void *nonNullValue = GlobalLoggingQueueIdentityKey; // Whatever, just not null
-		dispatch_queue_set_specific(loggingQueue, GlobalLoggingQueueIdentityKey, nonNullValue, NULL);
-		
-		queueSemaphore = dispatch_semaphore_create(LOG_MAX_QUEUE_SIZE);
-		
-		// Figure out how many processors are available.
-		// This may be used later for an optimization on uniprocessor machines.
-		
-		host_basic_info_data_t hostInfo;
-		mach_msg_type_number_t infoCount;
-		
-		infoCount = HOST_BASIC_INFO_COUNT;
-		host_info(mach_host_self(), HOST_BASIC_INFO, (host_info_t)&hostInfo, &infoCount);
-		
-		unsigned int result = (unsigned int)(hostInfo.max_cpus);
-		unsigned int one    = (unsigned int)(1);
-		
-		numProcessors = MAX(result, one);
-		
-		NSLogDebug(@"DDLog: numProcessors = %u", numProcessors);
-			
-		
-	#if TARGET_OS_IPHONE
-		NSString *notificationName = @"UIApplicationWillTerminateNotification";
-	#else
-		NSString *notificationName = @"NSApplicationWillTerminateNotification";
-	#endif
-		
-		[[NSNotificationCenter defaultCenter] addObserver:self
-		                                         selector:@selector(applicationWillTerminate:)
-		                                             name:notificationName
-		                                           object:nil];
-	}
+    static BOOL initialized = NO;
+    if (!initialized)
+    {
+        initialized = YES;
+        
+        loggers = [[NSMutableArray alloc] initWithCapacity:4];
+        
+        NSLogDebug(@"DDLog: Using grand central dispatch");
+        
+        loggingQueue = dispatch_queue_create("cocoa.lumberjack", NULL);
+        loggingGroup = dispatch_group_create();
+        
+        void *nonNullValue = GlobalLoggingQueueIdentityKey; // Whatever, just not null
+        dispatch_queue_set_specific(loggingQueue, GlobalLoggingQueueIdentityKey, nonNullValue, NULL);
+        
+        queueSemaphore = dispatch_semaphore_create(LOG_MAX_QUEUE_SIZE);
+        
+        // Figure out how many processors are available.
+        // This may be used later for an optimization on uniprocessor machines.
+        
+        host_basic_info_data_t hostInfo;
+        mach_msg_type_number_t infoCount;
+        
+        infoCount = HOST_BASIC_INFO_COUNT;
+        host_info(mach_host_self(), HOST_BASIC_INFO, (host_info_t)&hostInfo, &infoCount);
+        
+        unsigned int result = (unsigned int)(hostInfo.max_cpus);
+        unsigned int one    = (unsigned int)(1);
+        
+        numProcessors = MAX(result, one);
+        
+        NSLogDebug(@"DDLog: numProcessors = %u", numProcessors);
+            
+        
+    #if TARGET_OS_IPHONE
+        NSString *notificationName = @"UIApplicationWillTerminateNotification";
+    #else
+        NSString *notificationName = nil;
+
+        if (NSClassFromString(@"NSApplication"))
+        {
+            notificationName = @"NSApplicationWillTerminateNotification";
+        }
+        else
+        {
+            // If there is no NSApp -> we are running Command Line Tool app.
+            // In this case terminate notification wouldn't be fired, so we use workaround.
+            atexit_b(^{
+                [self applicationWillTerminate:nil];
+            });
+        }
+    #endif
+        
+        if (notificationName) {
+            [[NSNotificationCenter defaultCenter] addObserver:self
+                                                     selector:@selector(applicationWillTerminate:)
+                                                         name:notificationName
+                                                       object:nil];
+        }
+    }
 }
 
 /**
@@ -162,7 +184,7 @@ static unsigned int numProcessors;
 **/
 + (dispatch_queue_t)loggingQueue
 {
-	return loggingQueue;
+    return loggingQueue;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -171,7 +193,7 @@ static unsigned int numProcessors;
 
 + (void)applicationWillTerminate:(NSNotification *)notification
 {
-	[self flushLog];
+    [self flushLog];
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -180,30 +202,46 @@ static unsigned int numProcessors;
 
 + (void)addLogger:(id <DDLogger>)logger
 {
-	if (logger == nil) return;
-		
-	dispatch_async(loggingQueue, ^{ @autoreleasepool {
-		
-		[self lt_addLogger:logger];
-	}});
+    [self addLogger:logger withLogLevel:LOG_LEVEL_VERBOSE];
+}
+
++ (void)addLogger:(id <DDLogger>)logger withLogLevel:(int)logLevel
+{
+    if (logger == nil) return;
+    
+    dispatch_async(loggingQueue, ^{ @autoreleasepool {
+        
+        [self lt_addLogger:logger logLevel:logLevel];
+    }});
 }
 
 + (void)removeLogger:(id <DDLogger>)logger
 {
-	if (logger == nil) return;
-	
-	dispatch_async(loggingQueue, ^{ @autoreleasepool {
-		
-		[self lt_removeLogger:logger];
-	}});
+    if (logger == nil) return;
+    
+    dispatch_async(loggingQueue, ^{ @autoreleasepool {
+        
+        [self lt_removeLogger:logger];
+    }});
 }
 
 + (void)removeAllLoggers
 {
-	dispatch_async(loggingQueue, ^{ @autoreleasepool {
-		
-		[self lt_removeAllLoggers];
-	}});
+    dispatch_async(loggingQueue, ^{ @autoreleasepool {
+        
+        [self lt_removeAllLoggers];
+    }});
+}
+
++ (NSArray *)allLoggers
+{
+    __block NSArray *theLoggers;
+
+    dispatch_sync(loggingQueue, ^{ @autoreleasepool {
+        theLoggers = [self lt_allLoggers];
+    }});
+
+    return theLoggers;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -212,58 +250,58 @@ static unsigned int numProcessors;
 
 + (void)queueLogMessage:(DDLogMessage *)logMessage asynchronously:(BOOL)asyncFlag
 {
-	// We have a tricky situation here...
-	// 
-	// In the common case, when the queueSize is below the maximumQueueSize,
-	// we want to simply enqueue the logMessage. And we want to do this as fast as possible,
-	// which means we don't want to block and we don't want to use any locks.
-	// 
-	// However, if the queueSize gets too big, we want to block.
-	// But we have very strict requirements as to when we block, and how long we block.
-	// 
-	// The following example should help illustrate our requirements:
-	// 
-	// Imagine that the maximum queue size is configured to be 5,
-	// and that there are already 5 log messages queued.
-	// Let us call these 5 queued log messages A, B, C, D, and E. (A is next to be executed)
-	// 
-	// Now if our thread issues a log statement (let us call the log message F),
-	// it should block before the message is added to the queue.
-	// Furthermore, it should be unblocked immediately after A has been unqueued.
-	// 
-	// The requirements are strict in this manner so that we block only as long as necessary,
-	// and so that blocked threads are unblocked in the order in which they were blocked.
-	// 
-	// Returning to our previous example, let us assume that log messages A through E are still queued.
-	// Our aforementioned thread is blocked attempting to queue log message F.
-	// Now assume we have another separate thread that attempts to issue log message G.
-	// It should block until log messages A and B have been unqueued.
-	
-	
-	// We are using a counting semaphore provided by GCD.
-	// The semaphore is initialized with our LOG_MAX_QUEUE_SIZE value.
-	// Everytime we want to queue a log message we decrement this value.
-	// If the resulting value is less than zero,
-	// the semaphore function waits in FIFO order for a signal to occur before returning.
-	// 
-	// A dispatch semaphore is an efficient implementation of a traditional counting semaphore.
-	// Dispatch semaphores call down to the kernel only when the calling thread needs to be blocked.
-	// If the calling semaphore does not need to block, no kernel call is made.
-	
-	dispatch_semaphore_wait(queueSemaphore, DISPATCH_TIME_FOREVER);
-	
-	// We've now sure we won't overflow the queue.
-	// It is time to queue our log message.
-	
-	dispatch_block_t logBlock = ^{ @autoreleasepool {
-		
-		[self lt_log:logMessage];
-	}};
-	
-	if (asyncFlag)
-		dispatch_async(loggingQueue, logBlock);
-	else
-		dispatch_sync(loggingQueue, logBlock);
+    // We have a tricky situation here...
+    // 
+    // In the common case, when the queueSize is below the maximumQueueSize,
+    // we want to simply enqueue the logMessage. And we want to do this as fast as possible,
+    // which means we don't want to block and we don't want to use any locks.
+    // 
+    // However, if the queueSize gets too big, we want to block.
+    // But we have very strict requirements as to when we block, and how long we block.
+    // 
+    // The following example should help illustrate our requirements:
+    // 
+    // Imagine that the maximum queue size is configured to be 5,
+    // and that there are already 5 log messages queued.
+    // Let us call these 5 queued log messages A, B, C, D, and E. (A is next to be executed)
+    // 
+    // Now if our thread issues a log statement (let us call the log message F),
+    // it should block before the message is added to the queue.
+    // Furthermore, it should be unblocked immediately after A has been unqueued.
+    // 
+    // The requirements are strict in this manner so that we block only as long as necessary,
+    // and so that blocked threads are unblocked in the order in which they were blocked.
+    // 
+    // Returning to our previous example, let us assume that log messages A through E are still queued.
+    // Our aforementioned thread is blocked attempting to queue log message F.
+    // Now assume we have another separate thread that attempts to issue log message G.
+    // It should block until log messages A and B have been unqueued.
+    
+    
+    // We are using a counting semaphore provided by GCD.
+    // The semaphore is initialized with our LOG_MAX_QUEUE_SIZE value.
+    // Everytime we want to queue a log message we decrement this value.
+    // If the resulting value is less than zero,
+    // the semaphore function waits in FIFO order for a signal to occur before returning.
+    // 
+    // A dispatch semaphore is an efficient implementation of a traditional counting semaphore.
+    // Dispatch semaphores call down to the kernel only when the calling thread needs to be blocked.
+    // If the calling semaphore does not need to block, no kernel call is made.
+    
+    dispatch_semaphore_wait(queueSemaphore, DISPATCH_TIME_FOREVER);
+    
+    // We've now sure we won't overflow the queue.
+    // It is time to queue our log message.
+    
+    dispatch_block_t logBlock = ^{ @autoreleasepool {
+        
+        [self lt_log:logMessage];
+    }};
+    
+    if (asyncFlag)
+        dispatch_async(loggingQueue, logBlock);
+    else
+        dispatch_sync(loggingQueue, logBlock);
 }
 
 + (void)log:(BOOL)asynchronous
@@ -276,26 +314,26 @@ static unsigned int numProcessors;
         tag:(id)tag
      format:(NSString *)format, ...
 {
-	va_list args;
-	if (format)
-	{
-		va_start(args, format);
-		
-		NSString *logMsg = [[NSString alloc] initWithFormat:format arguments:args];
-		DDLogMessage *logMessage = [[DDLogMessage alloc] initWithLogMsg:logMsg
-		                                                          level:level
-		                                                           flag:flag
-		                                                        context:context
-		                                                           file:file
-		                                                       function:function
-		                                                           line:line
-		                                                            tag:tag
-		                                                        options:0];
-		
-		[self queueLogMessage:logMessage asynchronously:asynchronous];
-		
-		va_end(args);
-	}
+    va_list args;
+    if (format)
+    {
+        va_start(args, format);
+        
+        NSString *logMsg = [[NSString alloc] initWithFormat:format arguments:args];
+        DDLogMessage *logMessage = [[DDLogMessage alloc] initWithLogMsg:logMsg
+                                                                  level:level
+                                                                   flag:flag
+                                                                context:context
+                                                                   file:file
+                                                               function:function
+                                                                   line:line
+                                                                    tag:tag
+                                                                options:0];
+        
+        [self queueLogMessage:logMessage asynchronously:asynchronous];
+        
+        va_end(args);
+    }
 }
 
 + (void)log:(BOOL)asynchronous
@@ -309,29 +347,29 @@ static unsigned int numProcessors;
      format:(NSString *)format
        args:(va_list)args
 {
-	if (format)
-	{
-		NSString *logMsg = [[NSString alloc] initWithFormat:format arguments:args];
-		DDLogMessage *logMessage = [[DDLogMessage alloc] initWithLogMsg:logMsg
-		                                                          level:level
-		                                                           flag:flag
-		                                                        context:context
-		                                                           file:file
-		                                                       function:function
-		                                                           line:line
-		                                                            tag:tag
-		                                                        options:0];
-		
-		[self queueLogMessage:logMessage asynchronously:asynchronous];
-	}
+    if (format)
+    {
+        NSString *logMsg = [[NSString alloc] initWithFormat:format arguments:args];
+        DDLogMessage *logMessage = [[DDLogMessage alloc] initWithLogMsg:logMsg
+                                                                  level:level
+                                                                   flag:flag
+                                                                context:context
+                                                                   file:file
+                                                               function:function
+                                                                   line:line
+                                                                    tag:tag
+                                                                options:0];
+        
+        [self queueLogMessage:logMessage asynchronously:asynchronous];
+    }
 }
 
 + (void)flushLog
 {
-	dispatch_sync(loggingQueue, ^{ @autoreleasepool {
-		
-		[self lt_flush];
-	}});
+    dispatch_sync(loggingQueue, ^{ @autoreleasepool {
+        
+        [self lt_flush];
+    }});
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -340,352 +378,378 @@ static unsigned int numProcessors;
 
 + (BOOL)isRegisteredClass:(Class)class
 {
-	SEL getterSel = @selector(ddLogLevel);
-	SEL setterSel = @selector(ddSetLogLevel:);
-	
+    SEL getterSel = @selector(ddLogLevel);
+    SEL setterSel = @selector(ddSetLogLevel:);
+    
 #if TARGET_OS_IPHONE && !TARGET_IPHONE_SIMULATOR
-	
-	// Issue #6 (GoogleCode) - Crashes on iOS 4.2.1 and iPhone 4
-	// 
-	// Crash caused by class_getClassMethod(2).
-	// 
-	//     "It's a bug with UIAccessibilitySafeCategory__NSObject so it didn't pop up until
-	//      users had VoiceOver enabled [...]. I was able to work around it by searching the
-	//      result of class_copyMethodList() instead of calling class_getClassMethod()"
-	
-	BOOL result = NO;
-	
-	unsigned int methodCount, i;
-	Method *methodList = class_copyMethodList(object_getClass(class), &methodCount);
-	
-	if (methodList != NULL)
-	{
-		BOOL getterFound = NO;
-		BOOL setterFound = NO;
-		
-		for (i = 0; i < methodCount; ++i)
-		{
-			SEL currentSel = method_getName(methodList[i]);
-			
-			if (currentSel == getterSel)
-			{
-				getterFound = YES;
-			}
-			else if (currentSel == setterSel)
-			{
-				setterFound = YES;
-			}
-			
-			if (getterFound && setterFound)
-			{
-				result = YES;
-				break;
-			}
-		}
-		
-		free(methodList);
-	}
-	
-	return result;
-	
+    
+    // Issue #6 (GoogleCode) - Crashes on iOS 4.2.1 and iPhone 4
+    // 
+    // Crash caused by class_getClassMethod(2).
+    // 
+    //     "It's a bug with UIAccessibilitySafeCategory__NSObject so it didn't pop up until
+    //      users had VoiceOver enabled [...]. I was able to work around it by searching the
+    //      result of class_copyMethodList() instead of calling class_getClassMethod()"
+    
+    BOOL result = NO;
+    
+    unsigned int methodCount, i;
+    Method *methodList = class_copyMethodList(object_getClass(class), &methodCount);
+    
+    if (methodList != NULL)
+    {
+        BOOL getterFound = NO;
+        BOOL setterFound = NO;
+        
+        for (i = 0; i < methodCount; ++i)
+        {
+            SEL currentSel = method_getName(methodList[i]);
+            
+            if (currentSel == getterSel)
+            {
+                getterFound = YES;
+            }
+            else if (currentSel == setterSel)
+            {
+                setterFound = YES;
+            }
+            
+            if (getterFound && setterFound)
+            {
+                result = YES;
+                break;
+            }
+        }
+        
+        free(methodList);
+    }
+    
+    return result;
+    
 #else
-	
-	// Issue #24 (GitHub) - Crashing in in ARC+Simulator
-	// 
-	// The method +[DDLog isRegisteredClass] will crash a project when using it with ARC + Simulator.
-	// For running in the Simulator, it needs to execute the non-iOS code.
-	
-	Method getter = class_getClassMethod(class, getterSel);
-	Method setter = class_getClassMethod(class, setterSel);
-	
-	if ((getter != NULL) && (setter != NULL))
-	{
-		return YES;
-	}
-	
-	return NO;
-	
+    
+    // Issue #24 (GitHub) - Crashing in in ARC+Simulator
+    // 
+    // The method +[DDLog isRegisteredClass] will crash a project when using it with ARC + Simulator.
+    // For running in the Simulator, it needs to execute the non-iOS code.
+    
+    Method getter = class_getClassMethod(class, getterSel);
+    Method setter = class_getClassMethod(class, setterSel);
+    
+    if ((getter != NULL) && (setter != NULL))
+    {
+        return YES;
+    }
+    
+    return NO;
+    
 #endif
 }
 
 + (NSArray *)registeredClasses
 {
-	int numClasses, i;
-	
-	// We're going to get the list of all registered classes.
-	// The Objective-C runtime library automatically registers all the classes defined in your source code.
-	// 
-	// To do this we use the following method (documented in the Objective-C Runtime Reference):
-	// 
-	// int objc_getClassList(Class *buffer, int bufferLen)
-	// 
-	// We can pass (NULL, 0) to obtain the total number of
-	// registered class definitions without actually retrieving any class definitions.
-	// This allows us to allocate the minimum amount of memory needed for the application.
-	
-	numClasses = objc_getClassList(NULL, 0);
-	
-	// The numClasses method now tells us how many classes we have.
-	// So we can allocate our buffer, and get pointers to all the class definitions.
-	
-	Class *classes = (Class *)malloc(sizeof(Class) * numClasses);
-	
-	numClasses = objc_getClassList(classes, numClasses);
-	
-	// We can now loop through the classes, and test each one to see if it is a DDLogging class.
-	
-	NSMutableArray *result = [NSMutableArray arrayWithCapacity:numClasses];
-	
-	for (i = 0; i < numClasses; i++)
-	{
-		Class class = classes[i];
-		
-		if ([self isRegisteredClass:class])
-		{
-			[result addObject:class];
-		}
-	}
-	
-	free(classes);
-	
-	return result;
+    int numClasses, i;
+    
+    // We're going to get the list of all registered classes.
+    // The Objective-C runtime library automatically registers all the classes defined in your source code.
+    // 
+    // To do this we use the following method (documented in the Objective-C Runtime Reference):
+    // 
+    // int objc_getClassList(Class *buffer, int bufferLen)
+    // 
+    // We can pass (NULL, 0) to obtain the total number of
+    // registered class definitions without actually retrieving any class definitions.
+    // This allows us to allocate the minimum amount of memory needed for the application.
+    
+    numClasses = objc_getClassList(NULL, 0);
+    
+    // The numClasses method now tells us how many classes we have.
+    // So we can allocate our buffer, and get pointers to all the class definitions.
+    
+    Class *classes = (Class *)malloc(sizeof(Class) * numClasses);
+    if (classes == NULL) return nil;
+    
+    numClasses = objc_getClassList(classes, numClasses);
+    
+    // We can now loop through the classes, and test each one to see if it is a DDLogging class.
+    
+    NSMutableArray *result = [NSMutableArray arrayWithCapacity:numClasses];
+    
+    for (i = 0; i < numClasses; i++)
+    {
+        Class class = classes[i];
+        
+        if ([self isRegisteredClass:class])
+        {
+            [result addObject:class];
+        }
+    }
+    
+    free(classes);
+    
+    return result;
 }
 
 + (NSArray *)registeredClassNames
 {
-	NSArray *registeredClasses = [self registeredClasses];
-	NSMutableArray *result = [NSMutableArray arrayWithCapacity:[registeredClasses count]];
-	
-	for (Class class in registeredClasses)
-	{
-		[result addObject:NSStringFromClass(class)];
-	}
-	
-	return result;
+    NSArray *registeredClasses = [self registeredClasses];
+    NSMutableArray *result = [NSMutableArray arrayWithCapacity:[registeredClasses count]];
+    
+    for (Class class in registeredClasses)
+    {
+        [result addObject:NSStringFromClass(class)];
+    }
+    
+    return result;
 }
 
 + (int)logLevelForClass:(Class)aClass
 {
-	if ([self isRegisteredClass:aClass])
-	{
-		return [aClass ddLogLevel];
-	}
-	
-	return -1;
+    if ([self isRegisteredClass:aClass])
+    {
+        return [aClass ddLogLevel];
+    }
+    
+    return -1;
 }
 
 + (int)logLevelForClassWithName:(NSString *)aClassName
 {
-	Class aClass = NSClassFromString(aClassName);
-	
-	return [self logLevelForClass:aClass];
+    Class aClass = NSClassFromString(aClassName);
+    
+    return [self logLevelForClass:aClass];
 }
 
 + (void)setLogLevel:(int)logLevel forClass:(Class)aClass
 {
-	if ([self isRegisteredClass:aClass])
-	{
-		[aClass ddSetLogLevel:logLevel];
-	}
+    if ([self isRegisteredClass:aClass])
+    {
+        [aClass ddSetLogLevel:logLevel];
+    }
 }
 
 + (void)setLogLevel:(int)logLevel forClassWithName:(NSString *)aClassName
 {
-	Class aClass = NSClassFromString(aClassName);
-	
-	[self setLogLevel:logLevel forClass:aClass];
+    Class aClass = NSClassFromString(aClassName);
+    
+    [self setLogLevel:logLevel forClass:aClass];
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma mark Logging Thread
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-/**
- * This method should only be run on the logging thread/queue.
-**/
-+ (void)lt_addLogger:(id <DDLogger>)logger
++ (void)lt_addLogger:(id <DDLogger>)logger logLevel:(int)logLevel
 {
-	// Add to loggers array.
-	// Need to create loggerQueue if loggerNode doesn't provide one.
-	
-	dispatch_queue_t loggerQueue = NULL;
-	
-	if ([logger respondsToSelector:@selector(loggerQueue)])
-	{
-		// Logger may be providing its own queue
-		
-		loggerQueue = [logger loggerQueue];
-	}
-	
-	if (loggerQueue == nil)
-	{
-		// Automatically create queue for the logger.
-		// Use the logger name as the queue name if possible.
-		
-		const char *loggerQueueName = NULL;
-		if ([logger respondsToSelector:@selector(loggerName)])
-		{
-			loggerQueueName = [[logger loggerName] UTF8String];
-		}
-		
-		loggerQueue = dispatch_queue_create(loggerQueueName, NULL);
-	}
-	
-	DDLoggerNode *loggerNode = [DDLoggerNode nodeWithLogger:logger loggerQueue:loggerQueue];
-	[loggers addObject:loggerNode];
-	
-	if ([logger respondsToSelector:@selector(didAddLogger)])
-	{
-		dispatch_async(loggerNode->loggerQueue, ^{ @autoreleasepool {
-			
-			[logger didAddLogger];
-		}});
-	}
+    // Add to loggers array.
+    // Need to create loggerQueue if loggerNode doesn't provide one.
+
+    NSAssert(dispatch_get_specific(GlobalLoggingQueueIdentityKey),
+            @"This method should only be run on the logging thread/queue");
+    
+    dispatch_queue_t loggerQueue = NULL;
+    
+    if ([logger respondsToSelector:@selector(loggerQueue)])
+    {
+        // Logger may be providing its own queue
+        
+        loggerQueue = [logger loggerQueue];
+    }
+    
+    if (loggerQueue == nil)
+    {
+        // Automatically create queue for the logger.
+        // Use the logger name as the queue name if possible.
+        
+        const char *loggerQueueName = NULL;
+        if ([logger respondsToSelector:@selector(loggerName)])
+        {
+            loggerQueueName = [[logger loggerName] UTF8String];
+        }
+        
+        loggerQueue = dispatch_queue_create(loggerQueueName, NULL);
+    }
+    
+    DDLoggerNode *loggerNode = [DDLoggerNode nodeWithLogger:logger loggerQueue:loggerQueue logLevel:logLevel];
+    [loggers addObject:loggerNode];
+    
+    if ([logger respondsToSelector:@selector(didAddLogger)])
+    {
+        dispatch_async(loggerNode->loggerQueue, ^{ @autoreleasepool {
+            
+            [logger didAddLogger];
+        }});
+    }
 }
 
-/**
- * This method should only be run on the logging thread/queue.
-**/
 + (void)lt_removeLogger:(id <DDLogger>)logger
 {
-	// Find associated loggerNode in list of added loggers
-	
-	DDLoggerNode *loggerNode = nil;
-	
-	for (DDLoggerNode *node in loggers)
-	{
-		if (node->logger == logger)
-		{
-			loggerNode = node;
-			break;
-		}
-	}
-	
-	if (loggerNode == nil)
-	{
-		NSLogDebug(@"DDLog: Request to remove logger which wasn't added");
-		return;
-	}
-	
-	// Notify logger
-	
-	if ([logger respondsToSelector:@selector(willRemoveLogger)])
-	{
-		dispatch_async(loggerNode->loggerQueue, ^{ @autoreleasepool {
-			
-			[logger willRemoveLogger];
-		}});
-	}
-	
-	// Remove from loggers array
-	
-	[loggers removeObject:loggerNode];
+    // Find associated loggerNode in list of added loggers
+
+    NSAssert(dispatch_get_specific(GlobalLoggingQueueIdentityKey),
+            @"This method should only be run on the logging thread/queue");
+    
+    DDLoggerNode *loggerNode = nil;
+    
+    for (DDLoggerNode *node in loggers)
+    {
+        if (node->logger == logger)
+        {
+            loggerNode = node;
+            break;
+        }
+    }
+    
+    if (loggerNode == nil)
+    {
+        NSLogDebug(@"DDLog: Request to remove logger which wasn't added");
+        return;
+    }
+    
+    // Notify logger
+    
+    if ([logger respondsToSelector:@selector(willRemoveLogger)])
+    {
+        dispatch_async(loggerNode->loggerQueue, ^{ @autoreleasepool {
+            
+            [logger willRemoveLogger];
+        }});
+    }
+    
+    // Remove from loggers array
+    
+    [loggers removeObject:loggerNode];
 }
 
-/**
- * This method should only be run on the logging thread/queue.
-**/
 + (void)lt_removeAllLoggers
 {
-	// Notify all loggers
-	
-	for (DDLoggerNode *loggerNode in loggers)
-	{
-		if ([loggerNode->logger respondsToSelector:@selector(willRemoveLogger)])
-		{
-			dispatch_async(loggerNode->loggerQueue, ^{ @autoreleasepool {
-				
-				[loggerNode->logger willRemoveLogger];
-			}});
-		}
-	}
-	
-	// Remove all loggers from array
-	
-	[loggers removeAllObjects];
+    // Notify all loggers
+    
+    NSAssert(dispatch_get_specific(GlobalLoggingQueueIdentityKey),
+            @"This method should only be run on the logging thread/queue");
+
+    for (DDLoggerNode *loggerNode in loggers)
+    {
+        if ([loggerNode->logger respondsToSelector:@selector(willRemoveLogger)])
+        {
+            dispatch_async(loggerNode->loggerQueue, ^{ @autoreleasepool {
+                
+                [loggerNode->logger willRemoveLogger];
+            }});
+        }
+    }
+    
+    // Remove all loggers from array
+    
+    [loggers removeAllObjects];
+}
+
++ (NSArray *)lt_allLoggers
+{
+    NSAssert(dispatch_get_specific(GlobalLoggingQueueIdentityKey),
+            @"This method should only be run on the logging thread/queue");
+
+    NSMutableArray *theLoggers = [NSMutableArray new];
+
+    for (DDLoggerNode *loggerNode in loggers)
+    {
+        [theLoggers addObject:loggerNode->logger];
+    }
+
+    return [theLoggers copy];
 }
 
-/**
- * This method should only be run on the logging thread/queue.
-**/
 + (void)lt_log:(DDLogMessage *)logMessage
 {
-	// Execute the given log message on each of our loggers.
-		
-	if (numProcessors > 1)
-	{
-		// Execute each logger concurrently, each within its own queue.
-		// All blocks are added to same group.
-		// After each block has been queued, wait on group.
-		// 
-		// The waiting ensures that a slow logger doesn't end up with a large queue of pending log messages.
-		// This would defeat the purpose of the efforts we made earlier to restrict the max queue size.
-		
-		for (DDLoggerNode *loggerNode in loggers)
-		{
-			dispatch_group_async(loggingGroup, loggerNode->loggerQueue, ^{ @autoreleasepool {
-				
-				[loggerNode->logger logMessage:logMessage];
-			
-			}});
-		}
-		
-		dispatch_group_wait(loggingGroup, DISPATCH_TIME_FOREVER);
-	}
-	else
-	{
-		// Execute each logger serialy, each within its own queue.
-		
-		for (DDLoggerNode *loggerNode in loggers)
-		{
-			dispatch_sync(loggerNode->loggerQueue, ^{ @autoreleasepool {
-				
-				[loggerNode->logger logMessage:logMessage];
-				
-			}});
-		}
-	}
-	
-	// If our queue got too big, there may be blocked threads waiting to add log messages to the queue.
-	// Since we've now dequeued an item from the log, we may need to unblock the next thread.
-	
-	// We are using a counting semaphore provided by GCD.
-	// The semaphore is initialized with our LOG_MAX_QUEUE_SIZE value.
-	// When a log message is queued this value is decremented.
-	// When a log message is dequeued this value is incremented.
-	// If the value ever drops below zero,
-	// the queueing thread blocks and waits in FIFO order for us to signal it.
-	// 
-	// A dispatch semaphore is an efficient implementation of a traditional counting semaphore.
-	// Dispatch semaphores call down to the kernel only when the calling thread needs to be blocked.
-	// If the calling semaphore does not need to block, no kernel call is made.
-	
-	dispatch_semaphore_signal(queueSemaphore);
+    // Execute the given log message on each of our loggers.
+
+    NSAssert(dispatch_get_specific(GlobalLoggingQueueIdentityKey),
+            @"This method should only be run on the logging thread/queue");
+    
+    if (numProcessors > 1)
+    {
+        // Execute each logger concurrently, each within its own queue.
+        // All blocks are added to same group.
+        // After each block has been queued, wait on group.
+        // 
+        // The waiting ensures that a slow logger doesn't end up with a large queue of pending log messages.
+        // This would defeat the purpose of the efforts we made earlier to restrict the max queue size.
+        
+        for (DDLoggerNode *loggerNode in loggers)
+        {
+            // skip the loggers that shouldn't write this message based on the logLevel
+
+            if (!(logMessage->logFlag & loggerNode.logLevel))
+                continue;
+
+            dispatch_group_async(loggingGroup, loggerNode->loggerQueue, ^{ @autoreleasepool {
+                
+                [loggerNode->logger logMessage:logMessage];
+            
+            }});
+        }
+        
+        dispatch_group_wait(loggingGroup, DISPATCH_TIME_FOREVER);
+    }
+    else
+    {
+        // Execute each logger serialy, each within its own queue.
+        
+        for (DDLoggerNode *loggerNode in loggers)
+        {
+            // skip the loggers that shouldn't write this message based on the logLevel
+            
+            if (!(logMessage->logFlag & loggerNode.logLevel))
+                continue;
+
+            dispatch_sync(loggerNode->loggerQueue, ^{ @autoreleasepool {
+                
+                [loggerNode->logger logMessage:logMessage];
+                
+            }});
+        }
+    }
+    
+    // If our queue got too big, there may be blocked threads waiting to add log messages to the queue.
+    // Since we've now dequeued an item from the log, we may need to unblock the next thread.
+    
+    // We are using a counting semaphore provided by GCD.
+    // The semaphore is initialized with our LOG_MAX_QUEUE_SIZE value.
+    // When a log message is queued this value is decremented.
+    // When a log message is dequeued this value is incremented.
+    // If the value ever drops below zero,
+    // the queueing thread blocks and waits in FIFO order for us to signal it.
+    // 
+    // A dispatch semaphore is an efficient implementation of a traditional counting semaphore.
+    // Dispatch semaphores call down to the kernel only when the calling thread needs to be blocked.
+    // If the calling semaphore does not need to block, no kernel call is made.
+    
+    dispatch_semaphore_signal(queueSemaphore);
 }
 
-/**
- * This method should only be run on the background logging thread.
-**/
 + (void)lt_flush
 {
-	// All log statements issued before the flush method was invoked have now been executed.
-	// 
-	// Now we need to propogate the flush request to any loggers that implement the flush method.
-	// This is designed for loggers that buffer IO.
-		
-	for (DDLoggerNode *loggerNode in loggers)
-	{
-		if ([loggerNode->logger respondsToSelector:@selector(flush)])
-		{
-			dispatch_group_async(loggingGroup, loggerNode->loggerQueue, ^{ @autoreleasepool {
-				
-				[loggerNode->logger flush];
-				
-			}});
-		}
-	}
-	
-	dispatch_group_wait(loggingGroup, DISPATCH_TIME_FOREVER);
+    // All log statements issued before the flush method was invoked have now been executed.
+    // 
+    // Now we need to propogate the flush request to any loggers that implement the flush method.
+    // This is designed for loggers that buffer IO.
+
+    NSAssert(dispatch_get_specific(GlobalLoggingQueueIdentityKey),
+            @"This method should only be run on the logging thread/queue");
+        
+    for (DDLoggerNode *loggerNode in loggers)
+    {
+        if ([loggerNode->logger respondsToSelector:@selector(flush)])
+        {
+            dispatch_group_async(loggingGroup, loggerNode->loggerQueue, ^{ @autoreleasepool {
+                
+                [loggerNode->logger flush];
+                
+            }});
+        }
+    }
+    
+    dispatch_group_wait(loggingGroup, DISPATCH_TIME_FOREVER);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -694,74 +758,74 @@ static unsigned int numProcessors;
 
 NSString *DDExtractFileNameWithoutExtension(const char *filePath, BOOL copy)
 {
-	if (filePath == NULL) return nil;
-	
-	char *lastSlash = NULL;
-	char *lastDot = NULL;
-	
-	char *p = (char *)filePath;
-	
-	while (*p != '\0')
-	{
-		if (*p == '/')
-			lastSlash = p;
-		else if (*p == '.')
-			lastDot = p;
-		
-		p++;
-	}
-	
-	char *subStr;
-	NSUInteger subLen;
-	
-	if (lastSlash)
-	{
-		if (lastDot)
-		{
-			// lastSlash -> lastDot
-			subStr = lastSlash + 1;
-			subLen = lastDot - subStr;
-		}
-		else
-		{
-			// lastSlash -> endOfString
-			subStr = lastSlash + 1;
-			subLen = p - subStr;
-		}
-	}
-	else
-	{
-		if (lastDot)
-		{
-			// startOfString -> lastDot
-			subStr = (char *)filePath;
-			subLen = lastDot - subStr;
-		}
-		else
-		{
-			// startOfString -> endOfString
-			subStr = (char *)filePath;
-			subLen = p - subStr;
-		}
-	}
-	
-	if (copy)
-	{
-		return [[NSString alloc] initWithBytes:subStr
-		                                length:subLen
-		                              encoding:NSUTF8StringEncoding];
-	}
-	else
-	{
-		// We can take advantage of the fact that __FILE__ is a string literal.
-		// Specifically, we don't need to waste time copying the string.
-		// We can just tell NSString to point to a range within the string literal.
-		
-		return [[NSString alloc] initWithBytesNoCopy:subStr
-		                                      length:subLen
-		                                    encoding:NSUTF8StringEncoding
-		                                freeWhenDone:NO];
-	}
+    if (filePath == NULL) return nil;
+    
+    char *lastSlash = NULL;
+    char *lastDot = NULL;
+    
+    char *p = (char *)filePath;
+    
+    while (*p != '\0')
+    {
+        if (*p == '/')
+            lastSlash = p;
+        else if (*p == '.')
+            lastDot = p;
+        
+        p++;
+    }
+    
+    char *subStr;
+    NSUInteger subLen;
+    
+    if (lastSlash)
+    {
+        if (lastDot)
+        {
+            // lastSlash -> lastDot
+            subStr = lastSlash + 1;
+            subLen = lastDot - subStr;
+        }
+        else
+        {
+            // lastSlash -> endOfString
+            subStr = lastSlash + 1;
+            subLen = p - subStr;
+        }
+    }
+    else
+    {
+        if (lastDot)
+        {
+            // startOfString -> lastDot
+            subStr = (char *)filePath;
+            subLen = lastDot - subStr;
+        }
+        else
+        {
+            // startOfString -> endOfString
+            subStr = (char *)filePath;
+            subLen = p - subStr;
+        }
+    }
+    
+    if (copy)
+    {
+        return [[NSString alloc] initWithBytes:subStr
+                                        length:subLen
+                                      encoding:NSUTF8StringEncoding];
+    }
+    else
+    {
+        // We can take advantage of the fact that __FILE__ is a string literal.
+        // Specifically, we don't need to waste time copying the string.
+        // We can just tell NSString to point to a range within the string literal.
+        
+        return [[NSString alloc] initWithBytesNoCopy:subStr
+                                              length:subLen
+                                            encoding:NSUTF8StringEncoding
+                                        freeWhenDone:NO];
+    }
 }
 
 @end
@@ -772,32 +836,35 @@ NSString *DDExtractFileNameWithoutExtension(const char *filePath, BOOL copy)
 
 @implementation DDLoggerNode
 
-- (id)initWithLogger:(id <DDLogger>)aLogger loggerQueue:(dispatch_queue_t)aLoggerQueue
+@synthesize logLevel;
+
+- (instancetype)initWithLogger:(id <DDLogger>)aLogger loggerQueue:(dispatch_queue_t)aLoggerQueue logLevel:(int)aLogLevel
 {
-	if ((self = [super init]))
-	{
-		logger = aLogger;
-		
-		if (aLoggerQueue) {
-			loggerQueue = aLoggerQueue;
-			#if !OS_OBJECT_USE_OBJC
-			dispatch_retain(loggerQueue);
-			#endif
-		}
-	}
-	return self;
+    if ((self = [super init]))
+    {
+        logger = aLogger;
+        
+        if (aLoggerQueue) {
+            loggerQueue = aLoggerQueue;
+            #if !OS_OBJECT_USE_OBJC
+            dispatch_retain(loggerQueue);
+            #endif
+        }
+        logLevel = aLogLevel;
+    }
+    return self;
 }
 
-+ (DDLoggerNode *)nodeWithLogger:(id <DDLogger>)logger loggerQueue:(dispatch_queue_t)loggerQueue
++ (DDLoggerNode *)nodeWithLogger:(id <DDLogger>)logger loggerQueue:(dispatch_queue_t)loggerQueue logLevel:(int)logLevel
 {
-	return [[DDLoggerNode alloc] initWithLogger:logger loggerQueue:loggerQueue];
+    return [[DDLoggerNode alloc] initWithLogger:logger loggerQueue:loggerQueue logLevel:logLevel];
 }
 
 - (void)dealloc
 {
-	#if !OS_OBJECT_USE_OBJC
-	if (loggerQueue) dispatch_release(loggerQueue);
-	#endif
+    #if !OS_OBJECT_USE_OBJC
+    if (loggerQueue) dispatch_release(loggerQueue);
+    #endif
 }
 
 @end
@@ -810,102 +877,160 @@ NSString *DDExtractFileNameWithoutExtension(const char *filePath, BOOL copy)
 
 static char *dd_str_copy(const char *str)
 {
-	if (str == NULL) return NULL;
-	
-	size_t length = strlen(str);
-	char * result = malloc(length + 1);
-	strncpy(result, str, length);
-	result[length] = 0;
-	
-	return result;
+    if (str == NULL) return NULL;
+    
+    size_t length = strlen(str);
+    char * result = malloc(length + 1);
+    if (result == NULL) return NULL;
+    strncpy(result, str, length);
+    result[length] = 0;
+    
+    return result;
 }
 
-- (id)initWithLogMsg:(NSString *)msg
-               level:(int)level
-                flag:(int)flag
-             context:(int)context
-                file:(const char *)aFile
-            function:(const char *)aFunction
-                line:(int)line
-                 tag:(id)aTag
-             options:(DDLogMessageOptions)optionsMask
+- (instancetype)initWithLogMsg:(NSString *)msg
+                         level:(int)level
+                          flag:(int)flag
+                       context:(int)context
+                          file:(const char *)aFile
+                      function:(const char *)aFunction
+                          line:(int)line
+                           tag:(id)aTag
+                       options:(DDLogMessageOptions)optionsMask
 {
-	if ((self = [super init]))
-	{
-		logMsg     = msg;
-		logLevel   = level;
-		logFlag    = flag;
-		logContext = context;
-		lineNumber = line;
-		tag        = aTag;
-		options    = optionsMask;
-		
-		if (options & DDLogMessageCopyFile)
-			file = dd_str_copy(aFile);
-		else
-			file = (char *)aFile;
-		
-		if (options & DDLogMessageCopyFunction)
-			function = dd_str_copy(aFunction);
-		else
-			function = (char *)aFunction;
-		
-		timestamp = [[NSDate alloc] init];
-		
-		machThreadID = pthread_mach_thread_np(pthread_self());
-		
-		#pragma clang diagnostic push
-		#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-		// The documentation for dispatch_get_current_queue() states:
-		//
-		// > [This method is] "recommended for debugging and logging purposes only"...
-		//
-		// Well that's exactly how we're using it here. Literally for logging purposes only.
-		// However, Apple has decided to deprecate this method anyway.
-		// However they have not given us an alternate version of dispatch_queue_get_label() that
-		// automatically uses the current queue, thus dispatch_get_current_queue() is still required.
-		// 
-		// If dispatch_get_current_queue() disappears, without a dispatch_queue_get_label() alternative,
-		// Apple will have effectively taken away our ability to properly log the name of executing dispatch queue.
-		
-		dispatch_queue_t currentQueue = dispatch_get_current_queue();
-		#pragma clang diagnostic pop
-		
-		queueLabel = dd_str_copy(dispatch_queue_get_label(currentQueue));
-		
-		threadName = [[NSThread currentThread] name];
-	}
-	return self;
+    if ((self = [super init]))
+    {
+        logMsg     = msg;
+        logLevel   = level;
+        logFlag    = flag;
+        logContext = context;
+        lineNumber = line;
+        tag        = aTag;
+        options    = optionsMask;
+        
+        if (options & DDLogMessageCopyFile)
+            file = dd_str_copy(aFile);
+        else
+            file = (char *)aFile;
+        
+        if (options & DDLogMessageCopyFunction)
+            function = dd_str_copy(aFunction);
+        else
+            function = (char *)aFunction;
+        
+        timestamp = [[NSDate alloc] init];
+        
+        machThreadID = pthread_mach_thread_np(pthread_self());
+
+        // Try to get the current queue's label
+        
+        // a) Compiling against newer SDK's (iOS 7+/OS X 10.9+) where DISPATCH_CURRENT_QUEUE_LABEL is defined
+        //    on a (iOS 7.0+/OS X 10.9+) runtime version
+        BOOL gotLabel = NO;
+        #ifdef DISPATCH_CURRENT_QUEUE_LABEL
+        if (
+            #if TARGET_OS_IPHONE
+                #ifndef NSFoundationVersionNumber_iOS_6_1
+                #define NSFoundationVersionNumber_iOS_6_1 993.00
+                #endif
+                floor(NSFoundationVersionNumber) > NSFoundationVersionNumber_iOS_6_1 // iOS 7+ (> iOS 6.1)
+            #else
+                [NSTimer instancesRespondToSelector:@selector(tolerance)] // OS X 10.9+
+            #endif
+            ) {
+            queueLabel = dd_str_copy(dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL));
+            gotLabel = YES;
+        }
+        #endif
+        
+        // b) Systems where dispatch_get_current_queue is not yet deprecated and won't crash (< iOS 6.0/OS X 10.9)
+        //    dispatch_get_current_queue(void); __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_6,__MAC_10_9,__IPHONE_4_0,__IPHONE_6_0)
+        if (!gotLabel &&
+        #if TARGET_OS_IPHONE
+            #ifndef NSFoundationVersionNumber_iOS_6_0
+            #define NSFoundationVersionNumber_iOS_6_0 993.00
+            #endif
+            floor(NSFoundationVersionNumber) < NSFoundationVersionNumber_iOS_6_0 // < iOS 6.0
+        #else
+            ![NSTimer instancesRespondToSelector:@selector(tolerance)] // < OS X 10.9
+        #endif
+            ) {
+            #pragma clang diagnostic push
+            #pragma clang diagnostic ignored "-Wdeprecated-declarations"
+            dispatch_queue_t currentQueue = dispatch_get_current_queue();
+            #pragma clang diagnostic pop
+            
+            queueLabel = dd_str_copy(dispatch_queue_get_label(currentQueue));
+            gotLabel = YES;
+        }
+        
+        // c) Give up
+        if (!gotLabel) {
+            queueLabel = dd_str_copy(""); // iOS 6.x only
+        }
+        
+        threadName = [[NSThread currentThread] name];
+    }
+    return self;
 }
 
 - (NSString *)threadID
 {
-	return [[NSString alloc] initWithFormat:@"%x", machThreadID];
+    return [[NSString alloc] initWithFormat:@"%x", machThreadID];
 }
 
 - (NSString *)fileName
 {
-	return DDExtractFileNameWithoutExtension(file, NO);
+    return DDExtractFileNameWithoutExtension(file, NO);
 }
 
 - (NSString *)methodName
 {
-	if (function == NULL)
-		return nil;
-	else
-		return [[NSString alloc] initWithUTF8String:function];
+    if (function == NULL)
+        return nil;
+    else
+        return [[NSString alloc] initWithUTF8String:function];
 }
 
 - (void)dealloc
 {
-	if (file && (options & DDLogMessageCopyFile))
-		free(file);
-	
-	if (function && (options & DDLogMessageCopyFunction))
-		free(function);
-	
-	if (queueLabel)
-		free(queueLabel);
+    if (file && (options & DDLogMessageCopyFile))
+        free(file);
+    
+    if (function && (options & DDLogMessageCopyFunction))
+        free(function);
+    
+    if (queueLabel)
+        free(queueLabel);
+}
+
+
+- (id)copyWithZone:(NSZone *)zone {
+    DDLogMessage *newMessage = [[DDLogMessage alloc] init];
+    
+    newMessage->logLevel = self->logLevel;
+    newMessage->logFlag = self->logFlag;
+    newMessage->logContext = self->logContext;
+    newMessage->logMsg = self->logMsg;
+    newMessage->timestamp = self->timestamp;
+    
+    if (self->options & DDLogMessageCopyFile) {
+        newMessage->file = dd_str_copy(self->file);
+        newMessage->function = dd_str_copy(self->function);
+    } else {
+        newMessage->file = self->file;
+        newMessage->function = self->function;
+    }
+    
+    newMessage->lineNumber = self->lineNumber;
+    
+    newMessage->machThreadID = self->machThreadID;
+    newMessage->queueLabel = dd_str_copy(self->queueLabel);
+    newMessage->threadName = self->threadName;
+    newMessage->tag = self->tag;
+    newMessage->options = self->options;
+    
+    return newMessage;
 }
 
 @end
@@ -918,166 +1043,166 @@ static char *dd_str_copy(const char *str)
 
 - (id)init
 {
-	if ((self = [super init]))
-	{
-		const char *loggerQueueName = NULL;
-		if ([self respondsToSelector:@selector(loggerName)])
-		{
-			loggerQueueName = [[self loggerName] UTF8String];
-		}
-		
-		loggerQueue = dispatch_queue_create(loggerQueueName, NULL);
-		
-		// We're going to use dispatch_queue_set_specific() to "mark" our loggerQueue.
-		// Later we can use dispatch_get_specific() to determine if we're executing on our loggerQueue.
-		// The documentation states:
-		//
-		// > Keys are only compared as pointers and are never dereferenced.
-		// > Thus, you can use a pointer to a static variable for a specific subsystem or
-		// > any other value that allows you to identify the value uniquely.
-		// > Specifying a pointer to a string constant is not recommended.
-		//
-		// So we're going to use the very convenient key of "self",
-		// which also works when multiple logger classes extend this class, as each will have a different "self" key.
-		//
-		// This is used primarily for thread-safety assertions (via the isOnInternalLoggerQueue method below).
-		
-		void *key = (__bridge void *)self;
-		void *nonNullValue = (__bridge void *)self;
-		
-		dispatch_queue_set_specific(loggerQueue, key, nonNullValue, NULL);
-	}
-	return self;
+    if ((self = [super init]))
+    {
+        const char *loggerQueueName = NULL;
+        if ([self respondsToSelector:@selector(loggerName)])
+        {
+            loggerQueueName = [[self loggerName] UTF8String];
+        }
+        
+        loggerQueue = dispatch_queue_create(loggerQueueName, NULL);
+        
+        // We're going to use dispatch_queue_set_specific() to "mark" our loggerQueue.
+        // Later we can use dispatch_get_specific() to determine if we're executing on our loggerQueue.
+        // The documentation states:
+        //
+        // > Keys are only compared as pointers and are never dereferenced.
+        // > Thus, you can use a pointer to a static variable for a specific subsystem or
+        // > any other value that allows you to identify the value uniquely.
+        // > Specifying a pointer to a string constant is not recommended.
+        //
+        // So we're going to use the very convenient key of "self",
+        // which also works when multiple logger classes extend this class, as each will have a different "self" key.
+        //
+        // This is used primarily for thread-safety assertions (via the isOnInternalLoggerQueue method below).
+        
+        void *key = (__bridge void *)self;
+        void *nonNullValue = (__bridge void *)self;
+        
+        dispatch_queue_set_specific(loggerQueue, key, nonNullValue, NULL);
+    }
+    return self;
 }
 
 - (void)dealloc
 {
-	#if !OS_OBJECT_USE_OBJC
-	if (loggerQueue) dispatch_release(loggerQueue);
-	#endif
+    #if !OS_OBJECT_USE_OBJC
+    if (loggerQueue) dispatch_release(loggerQueue);
+    #endif
 }
 
 - (void)logMessage:(DDLogMessage *)logMessage
 {
-	// Override me
+    // Override me
 }
 
 - (id <DDLogFormatter>)logFormatter
 {
-	// This method must be thread safe and intuitive.
-	// Therefore if somebody executes the following code:
-	// 
-	// [logger setLogFormatter:myFormatter];
-	// formatter = [logger logFormatter];
-	// 
-	// They would expect formatter to equal myFormatter.
-	// This functionality must be ensured by the getter and setter method.
-	//
-	// The thread safety must not come at a cost to the performance of the logMessage method.
-	// This method is likely called sporadically, while the logMessage method is called repeatedly.
-	// This means, the implementation of this method:
-	// - Must NOT require the logMessage method to acquire a lock.
-	// - Must NOT require the logMessage method to access an atomic property (also a lock of sorts).
-	//
-	// Thread safety is ensured by executing access to the formatter variable on the loggerQueue.
-	// This is the same queue that the logMessage method operates on.
-	//
-	// Note: The last time I benchmarked the performance of direct access vs atomic property access,
-	// direct access was over twice as fast on the desktop and over 6 times as fast on the iPhone.
-	// 
-	// Furthermore, consider the following code:
-	//
-	// DDLogVerbose(@"log msg 1");
-	// DDLogVerbose(@"log msg 2");
-	// [logger setFormatter:myFormatter];
-	// DDLogVerbose(@"log msg 3");
-	//
-	// Our intuitive requirement means that the new formatter will only apply to the 3rd log message.
-	// This must remain true even when using asynchronous logging.
-	// We must keep in mind the various queue's that are in play here:
-	// 
-	// loggerQueue : Our own private internal queue that the logMessage method runs on.
-	//               Operations are added to this queue from the global loggingQueue.
-	// 
-	// globalLoggingQueue : The queue that all log messages go through before they arrive in our loggerQueue.
-	// 
-	// All log statements go through the serial gloabalLoggingQueue before they arrive at our loggerQueue.
-	// Thus this method also goes through the serial globalLoggingQueue to ensure intuitive operation.
-	
-	// IMPORTANT NOTE:
-	// 
-	// Methods within the DDLogger implementation MUST access the formatter ivar 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];
-	
-	__block id <DDLogFormatter> result;
-	
-	dispatch_sync(globalLoggingQueue, ^{
-		dispatch_sync(loggerQueue, ^{
-			result = formatter;
-		});
-	});
-	
-	return result;
+    // This method must be thread safe and intuitive.
+    // Therefore if somebody executes the following code:
+    // 
+    // [logger setLogFormatter:myFormatter];
+    // formatter = [logger logFormatter];
+    // 
+    // They would expect formatter to equal myFormatter.
+    // This functionality must be ensured by the getter and setter method.
+    //
+    // The thread safety must not come at a cost to the performance of the logMessage method.
+    // This method is likely called sporadically, while the logMessage method is called repeatedly.
+    // This means, the implementation of this method:
+    // - Must NOT require the logMessage method to acquire a lock.
+    // - Must NOT require the logMessage method to access an atomic property (also a lock of sorts).
+    //
+    // Thread safety is ensured by executing access to the formatter variable on the loggerQueue.
+    // This is the same queue that the logMessage method operates on.
+    //
+    // Note: The last time I benchmarked the performance of direct access vs atomic property access,
+    // direct access was over twice as fast on the desktop and over 6 times as fast on the iPhone.
+    // 
+    // Furthermore, consider the following code:
+    //
+    // DDLogVerbose(@"log msg 1");
+    // DDLogVerbose(@"log msg 2");
+    // [logger setFormatter:myFormatter];
+    // DDLogVerbose(@"log msg 3");
+    //
+    // Our intuitive requirement means that the new formatter will only apply to the 3rd log message.
+    // This must remain true even when using asynchronous logging.
+    // We must keep in mind the various queue's that are in play here:
+    // 
+    // loggerQueue : Our own private internal queue that the logMessage method runs on.
+    //               Operations are added to this queue from the global loggingQueue.
+    // 
+    // globalLoggingQueue : The queue that all log messages go through before they arrive in our loggerQueue.
+    // 
+    // All log statements go through the serial gloabalLoggingQueue before they arrive at our loggerQueue.
+    // Thus this method also goes through the serial globalLoggingQueue to ensure intuitive operation.
+    
+    // IMPORTANT NOTE:
+    // 
+    // Methods within the DDLogger implementation MUST access the formatter ivar 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];
+    
+    __block id <DDLogFormatter> result;
+    
+    dispatch_sync(globalLoggingQueue, ^{
+        dispatch_sync(loggerQueue, ^{
+            result = formatter;
+        });
+    });
+    
+    return result;
 }
 
 - (void)setLogFormatter:(id <DDLogFormatter>)logFormatter
 {
-	// The design of this method is documented extensively in the logFormatter message (above in code).
-	
-	NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
-	NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
-	
-	dispatch_block_t block = ^{ @autoreleasepool {
-		
-		if (formatter != logFormatter)
-		{
-			if ([formatter respondsToSelector:@selector(willRemoveFromLogger:)]) {
-				[formatter willRemoveFromLogger:self];
-			}
-			
-			formatter = logFormatter;
-			
-			if ([formatter respondsToSelector:@selector(didAddToLogger:)]) {
-				[formatter didAddToLogger:self];
-			}
-		}
-	}};
-	
-	dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
-	
-	dispatch_async(globalLoggingQueue, ^{
-		dispatch_async(loggerQueue, block);
-	});
+    // The design of this method is documented extensively in the logFormatter message (above in code).
+    
+    NSAssert(![self isOnGlobalLoggingQueue], @"Core architecture requirement failure");
+    NSAssert(![self isOnInternalLoggerQueue], @"MUST access ivar directly, NOT via self.* syntax.");
+    
+    dispatch_block_t block = ^{ @autoreleasepool {
+        
+        if (formatter != logFormatter)
+        {
+            if ([formatter respondsToSelector:@selector(willRemoveFromLogger:)]) {
+                [formatter willRemoveFromLogger:self];
+            }
+            
+            formatter = logFormatter;
+            
+            if ([formatter respondsToSelector:@selector(didAddToLogger:)]) {
+                [formatter didAddToLogger:self];
+            }
+        }
+    }};
+    
+    dispatch_queue_t globalLoggingQueue = [DDLog loggingQueue];
+    
+    dispatch_async(globalLoggingQueue, ^{
+        dispatch_async(loggerQueue, block);
+    });
 }
 
 - (dispatch_queue_t)loggerQueue
 {
-	return loggerQueue;
+    return loggerQueue;
 }
 
 - (NSString *)loggerName
 {
-	return NSStringFromClass([self class]);
+    return NSStringFromClass([self class]);
 }
 
 - (BOOL)isOnGlobalLoggingQueue
 {
-	return (dispatch_get_specific(GlobalLoggingQueueIdentityKey) != NULL);
+    return (dispatch_get_specific(GlobalLoggingQueueIdentityKey) != NULL);
 }
 
 - (BOOL)isOnInternalLoggerQueue
 {
-	void *key = (__bridge void *)self;
-	return (dispatch_get_specific(key) != NULL);
+    void *key = (__bridge void *)self;
+    return (dispatch_get_specific(key) != NULL);
 }
 
 @end