static ngx_int_t
ngx_http_groonga_context_init_logger(grn_ctx *context,
ngx_http_groonga_loc_conf_t *location_conf,
ngx_pool_t *pool,
ngx_log_t *log)
{
ngx_http_groonga_logger_data_t *logger_data;
if (!location_conf->log_file) {
return NGX_OK;
}
logger_data = ngx_pcalloc(pool, sizeof(ngx_http_groonga_logger_data_t));
if (!logger_data) {
ngx_log_error(NGX_LOG_ERR, log, 0,
"http_groonga: failed to allocate memory for logger");
return NGX_ERROR;
}
logger_data->pool = pool;
logger_data->file = location_conf->log_file;
ngx_http_groonga_logger.max_level = location_conf->log_level;
ngx_http_groonga_logger.user_data = logger_data;
grn_logger_set(context, &ngx_http_groonga_logger);
return NGX_OK;
}
static void
rb_grn_logger_reset_with_error_check (VALUE klass, grn_ctx *context)
{
VALUE current_logger;
current_logger = rb_cv_get(klass, "@@current_logger");
if (NIL_P(current_logger))
return;
rb_cv_set(klass, "@@current_logger", Qnil);
if (context) {
grn_logger_set(context, NULL);
rb_grn_context_check(context, current_logger);
} else {
grn_logger_set(NULL, NULL);
}
}
/* Deprecated since 2.1.2. */
grn_rc
grn_logger_info_set(grn_ctx *ctx, const grn_logger_info *info)
{
if (info) {
grn_logger logger;
memset(&logger, 0, sizeof(grn_logger));
logger.max_level = info->max_level;
logger.flags = info->flags;
if (info->func) {
logger.log = logger_info_func_wrapper;
logger.user_data = (grn_logger_info *)info;
} else {
logger.log = default_logger_log;
logger.reopen = default_logger_reopen;
logger.fin = default_logger_fin;
}
return grn_logger_set(ctx, &logger);
} else {
return grn_logger_set(ctx, NULL);
}
}
grn_rc
grn_windows_event_logger_set(grn_ctx *ctx, const char *event_source_name)
{
#ifdef WIN32
grn_rc rc;
grn_logger windows_event_logger;
grn_windows_event_logger_data *data;
if (ctx) {
GRN_API_ENTER;
}
data = malloc(sizeof(grn_windows_event_logger_data));
if (!data) {
if (ctx) {
ERR(GRN_NO_MEMORY_AVAILABLE,
"failed to allocate user data for Windows event logger");
GRN_API_RETURN(ctx->rc);
} else {
return GRN_NO_MEMORY_AVAILABLE;
}
}
if (event_source_name) {
data->event_source_name = grn_strdup_raw(event_source_name);
} else {
data->event_source_name = grn_strdup_raw("libgroonga");
}
data->event_source = INVALID_HANDLE_VALUE;
windows_event_logger.max_level = GRN_LOG_DEFAULT_LEVEL;
windows_event_logger.flags = GRN_LOG_TIME | GRN_LOG_MESSAGE;
windows_event_logger.user_data = data;
windows_event_logger.log = windows_event_logger_log;
windows_event_logger.reopen = windows_event_logger_reopen;
windows_event_logger.fin = windows_event_logger_fin;
rc = grn_logger_set(ctx, &windows_event_logger);
if (rc != GRN_SUCCESS) {
windows_event_logger.fin(ctx, windows_event_logger.user_data);
}
if (ctx) {
GRN_API_RETURN(rc);
} else {
return rc;
}
#else /* WIN32 */
return GRN_FUNCTION_NOT_IMPLEMENTED;
#endif /* WIN32 */
}
static ngx_int_t
ngx_http_groonga_context_init_logger(ngx_http_groonga_loc_conf_t *location_conf,
ngx_pool_t *pool,
ngx_log_t *log)
{
if (ngx_http_groonga_current_location_conf) {
ngx_http_groonga_current_location_conf->log_level =
grn_logger_get_max_level(context);
}
ngx_http_groonga_logger.max_level = location_conf->log_level;
ngx_http_groonga_logger.user_data = location_conf->log_file;
grn_logger_set(context, &ngx_http_groonga_logger);
return NGX_OK;
}
static void
ngx_http_groonga_handler_cleanup(void *user_data)
{
ngx_http_groonga_handler_data_t *data = user_data;
grn_ctx *context;
if (!data->initialized) {
return;
}
context = &(data->context);
GRN_OBJ_FIN(context, &(data->head));
GRN_OBJ_FIN(context, &(data->body));
GRN_OBJ_FIN(context, &(data->foot));
grn_logger_set(context, NULL);
grn_query_logger_set(context, NULL);
grn_ctx_fin(context);
}
/*
* Unregister the registered logger. The default logger is used after
* unregistering.
*
* @overload unregister
* @return void
*/
static VALUE
rb_grn_logger_s_unregister (VALUE klass)
{
VALUE current_logger;
VALUE rb_context = Qnil;
grn_ctx *context;
current_logger = rb_cv_get(klass, "@@current_logger");
if (NIL_P(current_logger))
return Qnil;
rb_cv_set(klass, "@@current_logger", Qnil);
context = rb_grn_context_ensure(&rb_context);
grn_logger_set(context, NULL);
rb_grn_context_check(context, klass);
return Qnil;
}
/*
* groongaがログを出力する度に呼び出されるブロックを登録する。
*
* @overload register(options={})
* @yield [event, level, time, title, message, location]
* _event_ と _level_ はSymbol、それ以外は全て文字列で渡される。
* _event_ と _level_ 以外
* の4つについては _options_ で +false+ を指定することでブロックに
* 渡さないようにすることができ、その場合は空文字列が実際には渡される。
* @param options [::Hash] The name and value
* pairs. Omitted names are initialized as the default value.
* @option options :max_level (:notice)
* ログのレベルを +:none+ , +:emergency+ , +:alert+ ,
* +:critical+ , +:error+ , +:warning+ , +:notice+ , +:info+ ,
* +:debug+ , +:dump+ のいずれかで指定する。それより重要度が
* 低いログはブロックに渡されなくなる。デフォルトでは +:notice+ 。
* @option options :time
* ログが出力された時間をブロックに渡したいなら +true+ を指
* 定する。デフォルトでは渡す。
* @option options :title
* ログのタイトルをブロックに渡したいなら +true+ を指定す
* る。デフォルトでは渡す。
* (FIXME: groongaで実装されていない?)
* @option options :message
* ログのメッセージをブロックに渡したいなら +true+ を指定す
* る。デフォルトでは渡す。
* @option options :location
* ログの発生元のプロセスIDとgroongaのソースコードのファイ
* ル名、行番号、関数名をブロックに渡したいなら +true+ を指
* 定する。デフォルトでは渡す。
*/
static VALUE
rb_grn_logger_s_register (int argc, VALUE *argv, VALUE klass)
{
VALUE rb_context = Qnil;
grn_ctx *context;
VALUE rb_logger, rb_callback;
VALUE rb_options, rb_max_level;
VALUE rb_time, rb_title, rb_message, rb_location;
VALUE rb_flags;
grn_log_level max_level = GRN_LOG_DEFAULT_LEVEL;
int flags = 0;
rb_scan_args(argc, argv, "02&", &rb_logger, &rb_options, &rb_callback);
if (rb_block_given_p()) {
if (!NIL_P(rb_logger)) {
rb_options = rb_logger;
}
rb_logger = rb_funcall(rb_cGrnCallbackLogger, id_new, 1, rb_callback);
}
rb_grn_scan_options(rb_options,
"max_level", &rb_max_level,
"time", &rb_time,
"title", &rb_title,
"message", &rb_message,
"location", &rb_location,
"flags", &rb_flags,
NULL);
if (!NIL_P(rb_max_level)) {
max_level = RVAL2GRNLOGLEVEL(rb_max_level);
}
if (NIL_P(rb_time) || CBOOL2RVAL(rb_time)) {
flags |= GRN_LOG_TIME;
}
if (NIL_P(rb_title) || CBOOL2RVAL(rb_title)) {
flags |= GRN_LOG_TITLE;
}
if (NIL_P(rb_message) || CBOOL2RVAL(rb_message)) {
flags |= GRN_LOG_MESSAGE;
}
if (NIL_P(rb_location) || CBOOL2RVAL(rb_location)) {
flags |= GRN_LOG_LOCATION;
}
if (!NIL_P(rb_flags)) {
flags = rb_funcall(rb_mGrnLoggerFlags, id_parse, 2,
INT2NUM(flags), rb_flags);
}
rb_grn_logger.max_level = max_level;
rb_grn_logger.flags = flags;
rb_grn_logger.user_data = (void *)rb_logger;
context = rb_grn_context_ensure(&rb_context);
grn_logger_set(context, &rb_grn_logger);
rb_grn_context_check(context, rb_logger);
rb_cv_set(klass, "@@current_logger", rb_logger);
return Qnil;
}
