zDWSI/defaultFrontend/access_log.go

package main

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

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, fmtstr string, useutc bool) {
	this.enable = true
	this.level_config = lvcfg
	this.commonLogger = NewCommonLogger(lvcfg.OutputLevel, wr)
	exdmap := map[string]int{
		"level":   8,
		"status":  3,
		"latency": 8,
		"cip":     20,
		"method":  8,
		"url":     1024,
	}
	this.commonLogger.SetFormatterWithCustomExData(fmtstr, exdmap, useutc)
}

func (this *AccessLogger) transStatusCode2Level(code int) DWSILogLevel {
	switch code {
	case 200:
		return this.level_config.SuccessLevel
	case 404:
		return this.level_config.NotFoundLevel
	case 403:
		return this.level_config.ForbiddenLevel
	case 502:
		return this.level_config.GatewayErrorLevel
	case 500:
		return this.level_config.InternalErrorLevel
	default:
		return this.level_config.SuccessLevel
	}
}

func (this *AccessLogger) Emit(tm time.Time, status int,
	latency time.Duration, cip string, method string, url string) {
	if this.enable {
		level := this.transStatusCode2Level(status)
		if level == LogLv_INVALID {
			return
		}
		lvstr := transLevelIntoLevelString(level)
		exd := map[string]string{
			"level":   lvstr,
			"status":  strconv.Itoa(status),
			"latency": fmt.Sprintf("%v", latency),
			"cip":     cip,
			"method":  method,
			"url":     url,
		}
		this.commonLogger.RawEmitWithCustomTime(level, tm, exd)
	}
}