Terminal ansi colors

include/private/target/stream.h

@@ -22,6 +22,7 @@
 #  include <stddef.h>
 #  include <stdio.h>
 #  include <stumpless/config.h>
+#  include <stumpless/entry.h>
 #  include "private/config/wrapper/thread_safety.h"
 
 /**
@@ -30,6 +31,8 @@
 struct stream_target {
 /** The stream this target writes to. */
   FILE *stream;
+/** ANSI colors for different severities (when using ansi terminal) */
+  char escape_codes[8][32];
 #  ifdef STUMPLESS_THREAD_SAFETY_SUPPORTED
 /**
  * Protects stream. This mutex must be locked by a thread before it can write
@@ -61,6 +64,7 @@ new_stream_target( FILE *stream );
 int
 sendto_stream_target( struct stream_target *target,
                       const char *msg,
-                      size_t msg_length );
+                      size_t msg_length,
+		      const struct stumpless_entry *entry );
 
 #endif /* __STUMPLESS_PRIVATE_TARGET_STREAM_H */

include/stumpless/severity.h

@@ -190,6 +190,20 @@ enum stumpless_severity {
   STUMPLESS_FOREACH_SEVERITY( STUMPLESS_GENERATE_ENUM )
 };
 
+/**
+ * The default stumpless ansi terminal color values
+ */
+#define STUMPLESS_SEVERITY_EMERG_DEFAULT_COLOR   "\33[31;1m"
+#define STUMPLESS_SEVERITY_ALERT_DEFAULT_COLOR   "\33[31;1m"
+#define STUMPLESS_SEVERITY_CRIT_DEFAULT_COLOR    "\33[31m"
+#define STUMPLESS_SEVERITY_ERR_DEFAULT_COLOR     "\33[31m"
+#define STUMPLESS_SEVERITY_WARNING_DEFAULT_COLOR "\33[33m"
+#define STUMPLESS_SEVERITY_NOTICE_DEFAULT_COLOR  "\33[32m"
+#define STUMPLESS_SEVERITY_INFO_DEFAULT_COLOR    "\33[37m"
+#define STUMPLESS_SEVERITY_DEBUG_DEFAULT_COLOR   "\33[0m"
+
+
+
 /**
  * Equivalent to the DEBUG severity. Trace level messages include extra
  * information, but do not have a distinct severity value in log entries.

include/stumpless/target/stream.h

@@ -38,6 +38,7 @@
 #  include <stdio.h>
 #  include <stumpless/config.h>
 #  include <stumpless/target.h>
+#  include <stumpless/severity.h>
 
 #  ifdef __cplusplus
 extern "C" {
@@ -154,6 +155,34 @@ STUMPLESS_PUBLIC_FUNCTION
 struct stumpless_target *
 stumpless_open_stream_target( const char *name, FILE *stream );
 
+/**
+ * Sets the ANSI escape code (https://en.wikipedia.org/wiki/ANSI_escape_code) to 
+ * be printed in a specific target when a log is made at some severity.
+ *
+ * It should be used with stdout or stderr as targets, since it is only for aesthetic purposes.
+ *
+ * **Thread Safety: MT-Safe race:escape_code**
+ * This function is thread safe, of course assuming that escape_code is not modified by
+ * any other threads during execution.
+ *
+ * **Async Signal Safety: AS-Unsafe lock**
+ * This function is not safe to call from signal handlers due to the destruction
+ * of a lock that may be in use.
+ *
+ * **Async Cancel Safety: AC-Unsafe lock**
+ * This function is not safe to call from threads that may be asynchronously
+ * cancelled, as the cleanup of the lock may not be completed.
+ *
+ * @param target The name of the target for which to set the colors.
+ *
+ * @param severity The severity code (LOG_ERR etc.) to which we set the specific color.
+ *
+ * @param escape_code The ANSI escape code representing the color.
+ */
+STUMPLESS_PUBLIC_FUNCTION
+void
+stumpless_set_severity_color( struct stumpless_target *target, enum stumpless_severity severity, const char *escape_code );
+
 #  ifdef __cplusplus
 }                               /* extern "C" */
 #  endif

src/target.c

@@ -267,7 +267,7 @@ stumpless_add_entry( struct stumpless_target *target,
       break;
 
     case STUMPLESS_STREAM_TARGET:
-      result = sendto_stream_target( target->id, buffer, builder_length );
+      result = sendto_stream_target( target->id, buffer, builder_length, entry );
       break;
 
     case STUMPLESS_WINDOWS_EVENT_LOG_TARGET:

src/target/stream.c

@@ -18,7 +18,10 @@
 
 #include <stddef.h>
 #include <stdio.h>
+#include <string.h>
 #include <stumpless/target.h>
+#include <stumpless/severity.h>
+#include <stumpless/entry.h>
 #include <stumpless/target/stream.h>
 #include "private/config/wrapper/locale.h"
 #include "private/config/wrapper/thread_safety.h"
@@ -28,6 +31,7 @@
 #include "private/target.h"
 #include "private/target/stream.h"
 #include "private/validate.h"
+#include "private/severity.h"
 
 void
 stumpless_close_stream_target( const struct stumpless_target *target ) {
@@ -48,12 +52,39 @@
 
 struct stumpless_target *
 stumpless_open_stderr_target( const char *name ) {
-  return stumpless_open_stream_target( name, stderr );
+  struct stumpless_target *target = stumpless_open_stream_target( name, stderr );
+
+  if (target == NULL) return NULL;
+
+  stumpless_set_severity_color(target, STUMPLESS_SEVERITY_EMERG_VALUE  , STUMPLESS_SEVERITY_EMERG_DEFAULT_COLOR  );
+  stumpless_set_severity_color(target, STUMPLESS_SEVERITY_ALERT_VALUE  , STUMPLESS_SEVERITY_ALERT_DEFAULT_COLOR  );
+  stumpless_set_severity_color(target, STUMPLESS_SEVERITY_CRIT_VALUE   , STUMPLESS_SEVERITY_CRIT_DEFAULT_COLOR   );
+  stumpless_set_severity_color(target, STUMPLESS_SEVERITY_ERR_VALUE    , STUMPLESS_SEVERITY_ERR_DEFAULT_COLOR    );
+  stumpless_set_severity_color(target, STUMPLESS_SEVERITY_WARNING_VALUE, STUMPLESS_SEVERITY_WARNING_DEFAULT_COLOR);
+  stumpless_set_severity_color(target, STUMPLESS_SEVERITY_NOTICE_VALUE , STUMPLESS_SEVERITY_NOTICE_DEFAULT_COLOR );
+  stumpless_set_severity_color(target, STUMPLESS_SEVERITY_INFO_VALUE   , STUMPLESS_SEVERITY_INFO_DEFAULT_COLOR   );
+  stumpless_set_severity_color(target, STUMPLESS_SEVERITY_DEBUG_VALUE  , STUMPLESS_SEVERITY_DEBUG_DEFAULT_COLOR  );
+
+  return target;
 }
 
 struct stumpless_target *
 stumpless_open_stdout_target( const char *name ) {
-  return stumpless_open_stream_target( name, stdout );
+  struct stumpless_target *target = stumpless_open_stream_target( name, stdout );
+
+  if (target == NULL) return NULL;
+
+  stumpless_set_severity_color(target, STUMPLESS_SEVERITY_EMERG_VALUE  , STUMPLESS_SEVERITY_EMERG_DEFAULT_COLOR  );
+  stumpless_set_severity_color(target, STUMPLESS_SEVERITY_ALERT_VALUE  , STUMPLESS_SEVERITY_ALERT_DEFAULT_COLOR  );
+  stumpless_set_severity_color(target, STUMPLESS_SEVERITY_CRIT_VALUE   , STUMPLESS_SEVERITY_CRIT_DEFAULT_COLOR   );
+  stumpless_set_severity_color(target, STUMPLESS_SEVERITY_ERR_VALUE    , STUMPLESS_SEVERITY_ERR_DEFAULT_COLOR    );
+  stumpless_set_severity_color(target, STUMPLESS_SEVERITY_WARNING_VALUE, STUMPLESS_SEVERITY_WARNING_DEFAULT_COLOR);
+  stumpless_set_severity_color(target, STUMPLESS_SEVERITY_NOTICE_VALUE , STUMPLESS_SEVERITY_NOTICE_DEFAULT_COLOR );
+  stumpless_set_severity_color(target, STUMPLESS_SEVERITY_INFO_VALUE   , STUMPLESS_SEVERITY_INFO_DEFAULT_COLOR   );
+  stumpless_set_severity_color(target, STUMPLESS_SEVERITY_DEBUG_VALUE  , STUMPLESS_SEVERITY_DEBUG_DEFAULT_COLOR  );
+
+
+  return target;
 }
 
 struct stumpless_target *
@@ -76,6 +107,9 @@
     goto fail_id;
   }
 
+  for (unsigned short i = 0; i < 8; i++)
+    ((struct stream_target *)(target->id))->escape_codes[i][0] = 0;
+
   stumpless_set_current_target( target );
   return target;
 
@@ -85,6 +119,30 @@
   return NULL;
 }
 
+void
+stumpless_set_severity_color( struct stumpless_target *target, enum stumpless_severity severity, const char *escape_code )
+{
+  if (severity_is_invalid(severity)) {
+    raise_invalid_severity(severity);
+    return;
+  }
+
+  lock_target(target);
+  if (target->type != STUMPLESS_STREAM_TARGET) {
+    raise_target_unsupported("This function is only supported for stream targets");
+    return;
+  }
+
+  struct stream_target *starget = (struct stream_target *)target->id;
+
+  strncpy(starget->escape_codes[severity], escape_code, 32);
+  starget->escape_codes[severity][31] = 0;
+
+  unlock_target(target);
+  clear_error();
+}
+
+
 /* private definitions */
 
 void
@@ -111,20 +169,44 @@
 int
 sendto_stream_target( struct stream_target *target,
                       const char *msg,
-                      size_t msg_length ) {
+                      size_t msg_length,
+                      const struct stumpless_entry *entry ) {
   size_t fwrite_result;
-
+  enum stumpless_severity severity = stumpless_get_entry_severity(entry);
+  const char *sev_code = target->escape_codes[severity];
+  unsigned short sev_code_len = strlen(sev_code);
+  const char *reset_code = "\33[0m";
+  unsigned short reset_code_len = strlen(reset_code);
+
   config_lock_mutex( &target->stream_mutex );
-  fwrite_result = fwrite( msg, sizeof( char ), msg_length, target->stream );
-  config_unlock_mutex( &target->stream_mutex );
+  if (sev_code_len != 0)
+  {
+    fwrite_result = fwrite( sev_code, sizeof( char ), sev_code_len, target->stream );
 
+    if( fwrite_result != sev_code_len ) {
+      goto write_failure;
+    }
+  }
+
+  fwrite_result = fwrite( msg, sizeof( char ), msg_length, target->stream );
   if( fwrite_result != msg_length ) {
     goto write_failure;
   }
 
+  if (sev_code_len != 0)
+  {
+    fwrite_result = fwrite( reset_code, sizeof( char ), reset_code_len, target->stream );
+
+    if( fwrite_result != reset_code_len ) {
+      goto write_failure;
+    }
+  }
+
+  config_unlock_mutex( &target->stream_mutex );
   return cap_size_t_to_int( fwrite_result + 1 );
 
 write_failure:
+  config_unlock_mutex( &target->stream_mutex );
   raise_stream_write_failure(  );
   return -1;
 }

src/windows/stumpless.def

@@ -246,3 +246,4 @@ EXPORTS
   stumpless_set_entry_message_str_w             @229
 
   stumpless_get_prival_string                   @230
+  stumpless_set_severity_color                  @231