zDWSI/defaultFrontend/access_log.go

package main

import (
	"fmt"
	"io"
	"strconv"
)

type AccessLoggerLevelConfig struct {
	OutputLevel        DWSILogLevel
	SuccessLevel       DWSILogLevel
	NotFoundLevel      DWSILogLevel
	ForbiddenLevel     DWSILogLevel
	GatewayErrorLevel  DWSILogLevel
	InternalErrorLevel DWSILogLevel
}

func transLevelStringIntoLevel(lvstr string) DWSILogLevel {
	switch lvstr {
	case "FATAL":
		return LogLv_FATAL
	case "PANIC":
		return LogLv_PANIC
	case "ERROR":
		return LogLv_ERROR
	case "WARN":
		return LogLv_WARN
	case "INFO":
		return LogLv_INFO
	case "DEBUG":
		return LogLv_DEBUG
	default:
		return LogLv_INVALID
	}
}

func transLevelIntoLevelString(lv DWSILogLevel) string {
	switch lv {
	case LogLv_FATAL:
		return "FATAL"
	case LogLv_PANIC:
		return "PANIC"
	case LogLv_ERROR:
		return "ERROR"
	case LogLv_WARN:
		return "WARN"
	case LogLv_INFO:
		return "INFO"
	case LogLv_DEBUG:
		return "DEBUG"
	default:
		return ""
	}
}

func ConvertLogLevelConfig(yamldata AccessLoggerConfigYAML) (error, *AccessLoggerLevelConfig) {
	o := &AccessLoggerLevelConfig{}
	o.OutputLevel = transLevelStringIntoLevel(yamldata.OutputLevel)
	o.SuccessLevel = transLevelStringIntoLevel(yamldata.SuccessLevel)
	o.NotFoundLevel = transLevelStringIntoLevel(yamldata.NotFoundLevel)
	o.ForbiddenLevel = transLevelStringIntoLevel(yamldata.ForbiddenLevel)
	o.GatewayErrorLevel = transLevelStringIntoLevel(yamldata.GatewayErrorLevel)
	o.InternalErrorLevel = transLevelStringIntoLevel(yamldata.InternalErrorLevel)
	if o.OutputLevel == 0 {
		return fmt.Errorf("invalid level name '%s' for output_level", yamldata.OutputLevel), o
	}
	if o.SuccessLevel == 0 {
		return fmt.Errorf("invalid level name '%s' for success_level", yamldata.SuccessLevel), o
	}
	if o.NotFoundLevel == 0 {
		return fmt.Errorf("invalid level name '%s' for not_found_level", yamldata.NotFoundLevel), o
	}
	if o.ForbiddenLevel == 0 {
		return fmt.Errorf("invalid level name '%s' for forbidden_level", yamldata.ForbiddenLevel), o
	}
	if o.GatewayErrorLevel == 0 {
		return fmt.Errorf("invalid level name '%s' for gateway_error_level", yamldata.GatewayErrorLevel), o
	}
	if o.InternalErrorLevel == 0 {
		return fmt.Errorf("invalid level name '%s' for internal_error_level", yamldata.InternalErrorLevel), o
	}
	return nil, o
}

type AccessLogger struct {
	enable       bool
	level_config *AccessLoggerLevelConfig
	commonLogger *CommonLogger
}

func NewAccessLogger() *AccessLogger {
	return &AccessLogger{
		enable:       false,
		level_config: nil,
		commonLogger: nil,
	}
}

func (this *AccessLogger) UseLogger(wr io.Writer, lvcfg *AccessLoggerLevelConfig) {
	this.enable = true
	this.level_config = lvcfg
	this.commonLogger = NewCommonLogger(lvcfg.OutputLevel, wr)
}

func (this *AccessLogger) Emit(level DWSILogLevel, url string, status int) {
	if this.enable {
		if level == LogLv_INVALID {
			return
		}
		lvstr := transLevelIntoLevelString(level)
		exd := map[string]string{
			"level":  lvstr,
			"status": strconv.Itoa(status),
			"url":    url,
		}
		this.commonLogger.RawEmit(level, exd)
	}
}

func (this *AccessLogger) LogResponse() {
	// TODO: Fix
}