typedef struct {
MonoLogCallback legacy_callback;
gpointer user_data;
-} legacyLoggerUserData;
+} UserSuppliedLoggerUserData;
/**
* mono_trace_init:
void
mono_tracev_inner (GLogLevelFlags level, MonoTraceMask mask, const char *format, va_list args)
{
+ char *log_message;
if (level_stack == NULL) {
mono_trace_init ();
if(level > mono_internal_current_level || !(mask & mono_internal_current_mask))
return;
}
- if (logCallback.opener == NULL) {
- logCallback.opener = mono_log_open_logfile;
- logCallback.writer = mono_log_write_logfile;
- logCallback.closer = mono_log_close_logfile;
- logCallback.opener(NULL, NULL);
- }
- logCallback.writer(mono_log_domain, level, logCallback.header, format, args);
+ g_assert (logCallback.opener); // mono_trace_init should have provided us with one!
+
+ if (g_vasprintf (&log_message, format, args) < 0)
+ return;
+ logCallback.writer (mono_log_domain, level, logCallback.header, log_message);
+ g_free (log_message);
}
/**
if(level_stack == NULL)
mono_trace_init();
+#if PLATFORM_ANDROID
+ logger.opener = mono_log_open_logcat;
+ logger.writer = mono_log_write_logcat;
+ logger.closer = mono_log_close_logcat;
+ logger.dest = (char*) dest;
+#elif defined (HOST_IOS)
+ logger.opener = mono_log_open_asl;
+ logger.writer = mono_log_write_asl;
+ logger.closer = mono_log_close_asl;
+ logger.dest = (char*) dest;
+#else
if ((dest == NULL) || (strcmp("syslog", dest) != 0)) {
logger.opener = mono_log_open_logfile;
logger.writer = mono_log_write_logfile;
logger.closer = mono_log_close_logfile;
logger.dest = (char *) dest;
- mono_trace_set_log_handler_internal(&logger, NULL);
} else {
logger.opener = mono_log_open_syslog;
logger.writer = mono_log_write_syslog;
logger.closer = mono_log_close_syslog;
logger.dest = (char *) dest;
- mono_trace_set_log_handler_internal(&logger, NULL);
}
+#endif
+ mono_trace_set_log_handler_internal(&logger, NULL);
}
/**
continue;
}
for (i = 0; valid_flags[i]; i++) {
- int len = strlen (valid_flags[i]);
+ size_t len = strlen (valid_flags[i]);
if (strncmp (tok, valid_flags[i], len) == 0 && (tok[len] == 0 || tok[len] == ',')) {
flags |= valid_masks[i];
tok += len;
* logging. We ignore the header request as legacy handlers never had headers.
*/
static void
-callback_adapter(const char *domain, GLogLevelFlags level, mono_bool fatal, const char *fmt, va_list args)
+callback_adapter (const char *domain, GLogLevelFlags level, mono_bool fatal, const char *message)
{
- legacyLoggerUserData *ll = (legacyLoggerUserData *) logCallback.user_data;
- const char *msg = g_strdup_vprintf (fmt, args);
+ UserSuppliedLoggerUserData *ll =logCallback.user_data;
- ll->legacy_callback (domain, log_level_get_name(level), msg, fatal, ll->user_data);
- g_free ((void *) msg);
+ ll->legacy_callback (domain, log_level_get_name(level), message, fatal, ll->user_data);
+}
+
+static void
+eglib_log_adapter (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data)
+{
+ UserSuppliedLoggerUserData *ll = logCallback.user_data;
+
+ ll->legacy_callback (log_domain, log_level_get_name (log_level), message, log_level & G_LOG_LEVEL_ERROR, ll->user_data);
}
/**
* Cleanup routine for older style loggers
*/
static void
-legacy_closer()
+legacy_closer(void)
{
if (logCallback.user_data != NULL) {
- g_free (logCallback.user_data); /* This is a LegacyLoggerUserData struct */
+ g_free (logCallback.user_data); /* This is a UserSuppliedLoggerUserData struct */
logCallback.opener = NULL;
logCallback.writer = NULL;
logCallback.closer = NULL;
*
* The log handler replaces the default runtime logger. All logging requests with be routed to it.
* If the fatal argument in the callback is true, the callback must abort the current process. The runtime expects that
- * execution will not resume after a fatal error. This is for "old-style" or legacy log handers.
+ * execution will not resume after a fatal error.
*/
void
mono_trace_set_log_handler (MonoLogCallback callback, void *user_data)
{
- g_assert (callback);
+ g_assert (callback);
+
if (logCallback.closer != NULL)
logCallback.closer();
- legacyLoggerUserData *ll = g_malloc (sizeof (legacyLoggerUserData));
+ UserSuppliedLoggerUserData *ll = g_malloc (sizeof (UserSuppliedLoggerUserData));
ll->legacy_callback = callback;
ll->user_data = user_data;
logCallback.opener = legacy_opener;
logCallback.closer = legacy_closer;
logCallback.user_data = ll;
logCallback.dest = NULL;
+
+ g_log_set_default_handler (eglib_log_adapter, user_data);
+}
+
+static void
+structured_log_adapter (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data)
+{
+ logCallback.writer (log_domain, log_level, logCallback.header, message);
}
/**
logCallback.closer = callback->closer;
logCallback.header = mono_trace_log_header;
logCallback.dest = callback->dest;
- logCallback.opener(logCallback.dest, user_data);
+ logCallback.opener (logCallback.dest, user_data);
+
+ g_log_set_default_handler (structured_log_adapter, user_data);
}
static void