void scribl_logfunc(const char *log_domain,
GLogLevelFlags log_level,
const char *message,
gpointer user_data)
{
char *base_level;
base_level = getenv("SCRIBL_LOG");
/* Log level 5 means log everything */
if(!base_level)
goto default_handler;
if (strcmp(base_level, "5") == 0) {
g_log_default_handler(log_domain, log_level, message, user_data);
} else if (strcmp(base_level, "4") == 0) {
if (log_level < G_LOG_LEVEL_DEBUG) {
g_log_default_handler(log_domain, log_level, message, user_data);
}
} else {
goto default_handler;
}
default_handler:
if (log_level < G_LOG_LEVEL_INFO)
g_log_default_handler(log_domain, log_level, message, user_data);
}
//_________________________________________________________
void LogHandler::glibLogHandler( const gchar* domain, GLogLevelFlags flags, const gchar* message, gpointer data )
{
if( std::string( message ).find( "g_object_ref" ) != std::string::npos ) return;
g_log_default_handler( domain, flags, message, data );
}
//_________________________________________________________
void LogHandler::gtkLogHandler( const gchar* domain, GLogLevelFlags flags, const gchar* message, gpointer data )
{
if( std::string( message ).find( "attempt to underallocate" ) != std::string::npos ) return;
g_log_default_handler( domain, flags, message, data );
}
static void
ibus_log_handler (const gchar *log_domain,
GLogLevelFlags log_level,
const gchar *message,
gpointer user_data)
{
// In the quiet mode (i.e. not verbose), we'll ignore DEBUG and
// WARNING messages.
if (!ibus_log_handler_is_verbose &&
((log_level & G_LOG_LEVEL_DEBUG) ||
(log_level & G_LOG_LEVEL_WARNING))) {
return;
}
// Add timing info like "17:34:57.680038" (hour, min, sec, microsecond).
struct timeval time_val;
gettimeofday (&time_val, NULL);
struct tm local_time;
localtime_r (&time_val.tv_sec, &local_time);
char* new_message =
g_strdup_printf ("%02d:%02d:%02d.%6d: %s",
local_time.tm_hour,
local_time.tm_min,
local_time.tm_sec,
(int)time_val.tv_usec,
message);
g_log_default_handler (log_domain, log_level, new_message, user_data);
g_free (new_message);
}
void logFilter(const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer unused_data)
{
if (log_level > sLogLevel) return;
if (sUseSyslog)
{
int priority;
switch (log_level & G_LOG_LEVEL_MASK) {
case G_LOG_LEVEL_ERROR:
priority = LOG_CRIT;
break;
case G_LOG_LEVEL_CRITICAL:
priority = LOG_ERR;
break;
case G_LOG_LEVEL_WARNING:
priority = LOG_WARNING;
break;
case G_LOG_LEVEL_MESSAGE:
priority = LOG_NOTICE;
break;
case G_LOG_LEVEL_DEBUG:
priority = LOG_DEBUG;
break;
case G_LOG_LEVEL_INFO:
default:
priority = LOG_INFO;
break;
}
syslog(priority, "%s", message);
}
else
{
g_log_default_handler(log_domain, log_level, message, unused_data);
}
}
static void
default_log_handler (const char *log_domain,
GLogLevelFlags log_level,
const char *message,
gpointer data)
{
TpDebugSender *sender = data;
GTimeVal now;
g_get_current_time (&now);
/* Send telepathy debug through DBus */
if (log_domain != NULL && g_str_has_prefix (log_domain, "tp-glib"))
tp_debug_sender_add_message (sender, &now, log_domain, log_level, message);
/* Filter out telepathy-glib logs, we don't want to flood Shell's output
* with those. */
if (!log_domain || !g_str_has_prefix (log_domain, "tp-glib"))
g_log_default_handler (log_domain, log_level, message, data);
/* Filter out Gjs logs, those already have the stack */
if (log_domain && strcmp (log_domain, "Gjs") == 0)
return;
if ((_shell_debug & SHELL_DEBUG_BACKTRACE_WARNINGS) &&
((log_level & G_LOG_LEVEL_CRITICAL) ||
(log_level & G_LOG_LEVEL_WARNING)))
gjs_dumpstack ();
}
static void
log_handler (gchar * log_domain,
GLogLevelFlags mask, const gchar * message, gpointer user_data)
{
if (mask & appdata.debug_mask)
g_log_default_handler ("EtherApe", mask, message, user_data);
}
void my_log_handler (const gchar * log_domain,
GLogLevelFlags log_level,
const gchar * message, gpointer unused_data)
{
/* Do not pass fatal flags so that we can show the backtrace. */
g_log_default_handler (log_domain, log_level & G_LOG_LEVEL_MASK, message,
unused_data);
switch ((log_level & G_LOG_FATAL_MASK) ? G_LOG_LEVEL_ERROR : log_level)
{
case G_LOG_LEVEL_ERROR:
case G_LOG_LEVEL_CRITICAL:
case G_LOG_LEVEL_WARNING:
case G_LOG_LEVEL_MESSAGE:
_glib_vm_proxy->showBacktrace (stderr);
break;
default:
_glib_vm_proxy->showBacktrace (stdout);
break;
}
if (log_level & G_LOG_FATAL_MASK)
abort ();
}
static void
bug_buddy_log_handler (const gchar *log_domain,
GLogLevelFlags log_level,
const gchar *message,
gpointer user_data)
{
/* forward the message to the real handler and use the default GLib
* handler if that's NULL (should never happen, but who knows).
*/
if (old_handler) {
old_handler (log_domain, log_level, message, user_data);
} else {
g_log_default_handler (log_domain, log_level, message, user_data);
}
if (log_level &
(G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_FLAG_FATAL))
{
/* log the message into memory */
if (!log_buff) {
log_buff = circ_buff_new (LOG_BUFFER_SIZE);
}
/* if the log domain is NULL, assume it's a message coming from the app,
* see the docs for G_LOG_DOMAIN.
*/
circ_add (log_buff, g_strdup_printf ("** %s **: %s \n", log_domain ? log_domain : g_get_prgname (), message));
}
}
static void handler_log(const gchar *domain, GLogLevelFlags level, const gchar *msg, gpointer data)
{
gchar *time_str;
if (G_LIKELY(app != NULL && app->debug_mode) ||
! ((G_LOG_LEVEL_DEBUG | G_LOG_LEVEL_INFO | G_LOG_LEVEL_MESSAGE) & level))
{
#ifdef G_OS_WIN32
/* On Windows g_log_default_handler() is not enough, we need to print it
* explicitly on stderr for the console window */
/** TODO this can be removed if/when we remove the console window on Windows */
if (domain != NULL)
fprintf(stderr, "%s: %s\n", domain, msg);
else
fprintf(stderr, "%s\n", msg);
#else
/* print the message as usual on stdout/stderr */
g_log_default_handler(domain, level, msg, data);
#endif
}
time_str = utils_get_current_time_string();
g_string_append_printf(log_buffer, "%s: %s %s: %s\n", time_str, domain,
get_log_prefix(level), msg);
g_free(time_str);
update_dialog();
}
static void
gst_gl_window_log_handler (const gchar * domain, GLogLevelFlags flags,
const gchar * message, gpointer user_data)
{
if (_gst_gl_window_debug) {
g_log_default_handler (domain, flags, message, user_data);
}
}
static void log_handler(gchar const* log_domain, GLogLevelFlags log_level, gchar const* message, gpointer user_data) {
gboolean* verbose = user_data;
if (!*verbose && log_level > G_LOG_LEVEL_MESSAGE)
return;
g_log_default_handler (log_domain, log_level, message, NULL);
}
static void
_j4status_core_debug_log_handler(const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data)
{
GDataOutputStream *stream = user_data;
g_log_default_handler(log_domain, log_level, message, NULL);
const gchar *prg_name;
gchar pid[128];
prg_name = g_get_prgname();
g_sprintf(pid, "%lu", (gulong) getpid());
g_data_output_stream_put_string(stream, "(", NULL, NULL);
if ( prg_name != NULL )
{
g_data_output_stream_put_string(stream, prg_name, NULL, NULL);
g_data_output_stream_put_string(stream, ":", NULL, NULL);
}
else
g_data_output_stream_put_string(stream, "process:", NULL, NULL);
g_data_output_stream_put_string(stream, pid, NULL, NULL);
g_data_output_stream_put_string(stream, ") ", NULL, NULL);
const gchar *log_level_message = "";
switch ( log_level & G_LOG_LEVEL_MASK )
{
case G_LOG_LEVEL_ERROR:
log_level_message = "ERROR";
break;
case G_LOG_LEVEL_CRITICAL:
log_level_message = "CRITICAL";
break;
case G_LOG_LEVEL_WARNING:
log_level_message = "WARNING";
break;
case G_LOG_LEVEL_MESSAGE:
log_level_message = "MESSAGE";
break;
case G_LOG_LEVEL_INFO:
log_level_message = "INFO";
break;
case G_LOG_LEVEL_DEBUG:
log_level_message = "DEBUG";
break;
}
g_data_output_stream_put_string(stream, log_level_message, NULL, NULL);
if ( log_domain != NULL )
{
g_data_output_stream_put_string(stream, " [", NULL, NULL);
g_data_output_stream_put_string(stream, log_domain, NULL, NULL);
g_data_output_stream_put_string(stream, "]", NULL, NULL);
}
g_data_output_stream_put_string(stream, ": ", NULL, NULL);
g_data_output_stream_put_string(stream, message, NULL, NULL);
g_data_output_stream_put_byte(stream, '\n', NULL, NULL);
}
static void
debug_log_handler (const gchar * log_domain,
GLogLevelFlags log_level, const gchar * message, gpointer user_data)
{
g_log_default_handler (log_domain, log_level, message, user_data);
/* FIXME: do we still need this ? fatal errors these days are all
* other than core errors */
/* g_on_error_query (NULL); */
}
static void
info_log_cb (const char *log_domain,
GLogLevelFlags log_level,
const char *message,
gpointer user_data)
{
if (arg_enable_info)
g_log_default_handler(log_domain, log_level, message, user_data);
}
static void
silent_log_handler (const gchar *log_domain,
GLogLevelFlags log_level,
const gchar *message,
gpointer data)
{
if (log_level & G_LOG_LEVEL_ERROR)
g_log_default_handler (log_domain, log_level, message, data);
}
static void
_my_log_handler (const gchar *log_domain,
GLogLevelFlags log_level,
const gchar *message,
gpointer user_data)
{
if (g_verbose) {
g_log_default_handler (log_domain, log_level, message, user_data);
}
}
void
g_log_filter(const gchar *log_domain,
GLogLevelFlags log_level,
const gchar *message,
gpointer unused_data)
{
if (log_level > sLogLevel) return;
g_log_default_handler(log_domain, log_level, message, unused_data);
}
static void
nmt_newt_basic_g_log_handler (const char *log_domain,
GLogLevelFlags log_level,
const char *message,
gpointer user_data)
{
newtSuspend ();
g_log_default_handler (log_domain, log_level, message, NULL);
newtResume ();
}
void
log_default_handler (const gchar *log_domain,
GLogLevelFlags log_level,
const gchar *message,
gpointer unused_data)
{
if ((log_level & log_levels) != 0) {
g_log_default_handler (log_domain, log_level, message, unused_data);
}
}
void log_filter(const gchar *log_domain, GLogLevelFlags log_level,
const gchar *message, gpointer user_data)
{
if (strstr(message, "BitBlt failed: The handle is invalid")) {
// ignore this error - known bug in Gdk.
// happens when the screen saver activates while user is hovering over a thumbnail
return;
}
g_log_default_handler(log_domain, log_level, message, user_data);
}
static void
gvc_log_default_handler (const gchar *log_domain,
GLogLevelFlags log_level,
const gchar *message,
gpointer unused_data)
{
if ((log_level & log_levels) == 0)
return;
g_log_default_handler (log_domain, log_level, message, unused_data);
}
void log_to_file(const gchar* log_domain, GLogLevelFlags log_level, const gchar* message, char* app_name)
{
char* log_file_path = g_strdup_printf("/tmp/%s.log", app_name);
FILE *logfile = fopen(log_file_path, "a");
g_free(log_file_path);
if (logfile != NULL) {
fprintf(logfile, "%s\n", message);
fclose(logfile);
}
g_log_default_handler(log_domain, log_level, message, NULL);
}
/* Stop in the debugger after running the default log handler.
* This makes certain kinds of messages stop in the debugger
* without making them fatal (you can continue).
*/
static void
log_handler (const char *domain,
GLogLevelFlags level,
const char *message,
gpointer data)
{
g_log_default_handler (domain, level, message, data);
if ((level & (G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING)) != 0) {
eel_stop_in_debugger ();
}
}
static void rygel_log_handler_log_func (RygelLogHandler* self, const char* log_domain, GLogLevelFlags log_levels, const char* message) {
#line 69 "rygel-log-handler.vala"
g_return_if_fail (self != NULL);
#line 69 "rygel-log-handler.vala"
g_return_if_fail (message != NULL);
#line 72 "rygel-log-handler.vala"
if ((self->levels & log_levels) == log_levels) {
#line 74 "rygel-log-handler.vala"
g_log_default_handler (log_domain, log_levels, message, NULL);
#line 250 "rygel-log-handler.c"
}
}
static void log_handler
(const gchar *log_domain,
GLogLevelFlags log_level,
const gchar *message,
gpointer unused_data) {
g_log_default_handler(log_domain, log_level, message, unused_data);
if((log_level & G_LOG_FLAG_FATAL) && NTask > 1) {
g_on_error_stack_trace ("");
abort();
}
}
static void
log_handler (const gchar *domain,
GLogLevelFlags level,
const gchar *message,
gpointer data)
{
/* filter out DEBUG messages if debug isn't set */
if ((level & G_LOG_LEVEL_MASK) == G_LOG_LEVEL_DEBUG && !debug)
return;
g_log_default_handler (domain, level, message, data);
}
static void
stop_after_log (const char *domain, GLogLevelFlags level,
const char *message, gpointer data)
{
void (* saved_handler) (int);
g_log_default_handler (domain, level, message, data);
saved_handler = signal (SIGINT, SIG_IGN);
raise (SIGINT);
signal (SIGINT, saved_handler);
}
// logging stuff
static void debug_log_handler (const gchar *log_domain,
GLogLevelFlags log_level,
const gchar *message,
gpointer user_data)
{
if (log_domain && strcmp(log_domain, "hooks") == 0) {
if (HOOK_DEBUG)
g_log_default_handler (log_domain, log_level, message, user_data);
}
else if (log_domain && strcmp(log_domain, "update") == 0) {
if (UPDATE_DEBUG)
g_log_default_handler (log_domain, log_level, message, user_data);
}
else if (log_domain && strcmp(log_domain, "inotify") == 0) {
if (INOTIFY_DEBUG)
g_log_default_handler (log_domain, log_level, message, user_data);
}
else if (log_domain && strcmp(log_domain, "uevent") == 0) {
if (UEVENT_DEBUG)
g_log_default_handler (log_domain, log_level, message, user_data);
}
else if (log_domain && strcmp(log_domain, "release") == 0) {
if (RELEASE_DEBUG)
g_log_default_handler (log_domain, log_level, message, user_data);
}
else if (MISC_DEBUG)
g_log_default_handler (log_domain, log_level, message, user_data);
}
static void prv_handler(const gchar *log_domain,
GLogLevelFlags log_level,
const gchar *message,
gpointer data)
{
dleyna_log_t *log_context = (dleyna_log_t *)(data);
if (g_strcmp0(log_domain, s_log_context.log_domain))
return;
if (log_context->flags & log_level)
g_log_default_handler(log_domain, log_level, message, data);
}
