mon_log_cb ()

void        (*mon_log_cb)                   (int level,
                                             const char *fmt,
                                             va_list ap);

Specifies the type of the function which is passed to mon_log_set_cb().

This function is passed a log level and a message.

mon_log_set_cb ()

void        mon_log_set_cb                  (mon_log_cb cb);

Sets the log callback to the specified function.

mon_log_get_cb ()

mon_log_cb  mon_log_get_cb                  (void);

Returns the current log callback function.

mon_log ()

void        mon_log                         (int level,
                                             const char *fmt,
                                             ...);

Logs a message, similar to syslog. If the level is higher than the current log level, the message is passed to the callback function set by mon_log_set_cb(); otherwise the message is dropped.

mon_vlog ()

void        mon_vlog                        (int level,
                                             const char *fmt,
                                             va_list ap);

Same as mon_log, but accepts a va_list instead of a variable number of arguments.

mon_log_set_level ()

int         mon_log_set_level               (int level);

Sets the log level. Messages that are less severe than the log level will not be logged.

mon_log_set_level_str ()

int         mon_log_set_level_str           (const char *level_str);

Sets the log level parsed from a string. The known log levels in decreasing priority order are "crit", "err", "warning", "notice", "info", and "debug".

mon_log_to_stderr ()

void        mon_log_to_stderr               (int level,
                                             const char *fmt,
                                             va_list ap);

Logs messages to the standard error. The address of this function can be passed to mon_log_set_cb().

mon_log_default ()

void        mon_log_default                 (int level,
                                             const char *fmt,
                                             va_list ap);

Implements the default log callback function used by most of the monitoring system. It supports user-modifyable log target and log identity settings. The address of this function can be passed to mon_log_set_cb().

mon_log_default_close ()

void        mon_log_default_close           (int freeall);

Closes the log target of the mon_log_default() callback.

mon_log_default_reopen ()

void        mon_log_default_reopen          (void);

Re-opens the log target used by the mon_log_default() callback.

mon_log_default_parse_cfg ()

int         mon_log_default_parse_cfg       (mon_cfg_node *cfg,
                                             const char *def_ident,
                                             const char *def_target,
                                             int def_level);

Sets up logging based on values in a configuration tree. The log target is set to the value of the "LogTarget" configuration key, the identity to the value of the "LogIdent" key, and the log level to the value of the "LogLevel" key. If one or more of these keys are missing, the respective default value as specified in def_ident, def_target and def_level will be used. See mon_log_set_level_str() for the possible values of the "LogLevel" key. See mon_log_default_set_target() for the format of the "LogTarget" key.

mon_log_default_parse_env ()

void        mon_log_default_parse_env       (void);

Sets up logging based on the value of an environment variable. The monitoring system uses the MERCURY_OPTIONS variable by default.

mon_log_default_set_ident ()

int         mon_log_default_set_ident       (const char *ident);

Sets the identity string used in log messages.

mon_log_default_set_target ()

int         mon_log_default_set_target      (const char *logtarget);

Sets the log target. logtarget must have the form "selector:[target]". The known selectors are:

mon_loginfo_register ()

int         mon_loginfo_register            (const char *name,
                                             int *addr);

Register a per-component log level indicator. If mon_loginfo_set() was called previously for the component, the log level will be set automatically.

mon_loginfo_unregister ()

void        mon_loginfo_unregister          (const char *name);

Unregisters a per-component log level indicator.

mon_loginfo_set ()

void        mon_loginfo_set                 (const char *name,
                                             int value);

Sets a per-component log level indicator. May be called before the indicator is registered; in this case, the log level will be set when mon_loginfo_register() is called for the component.

mon_loginfo_set_default ()

void        mon_loginfo_set_default         (int value);

Set the default log level to use when no explicit mon_loginfo_set() was called for a component.