GoHiedaLogger/hieda_yamlutil/yamlutil.go

package hieda_yamlutil

import (
	"fmt"
	"git.swzry.com/zry/GoHiedaLogger/hiedabke_alisls"
	"git.swzry.com/zry/GoHiedaLogger/hiedabke_writer"
	"git.swzry.com/zry/GoHiedaLogger/hiedalog"
	"gopkg.in/natefinch/lumberjack.v2"
	"io"
	"os"
)

func (hyu *HiedaLogYamlUtil) parseConsoleBackend(backend CommonLogConfigYAML_Backend) (hiedalog.HiedaLogBackend, error) {
	if backend.ConsoleConfig == nil {
		return nil, fmt.Errorf("no field named 'console_config' for backend type 'console'")
	}
	switch backend.ConsoleConfig.To {
	case "stdout":
		return NewSimpleConsoleBackend(os.Stdout), nil
	case "stderr":
		return NewSimpleConsoleBackend(os.Stderr), nil
	default:
		return nil, fmt.Errorf("invalid target '%s' for 'to' field of 'console_config'", backend.ConsoleConfig.To)
	}
}

func (hyu *HiedaLogYamlUtil) parseFileBackend(backend CommonLogConfigYAML_Backend) (hiedalog.HiedaLogBackend, error) {
	if backend.FileConfig == nil {
		return nil, fmt.Errorf("no field named 'file_config' for backend type 'file'")
	}
	var iof io.Writer
	if backend.FileConfig.Rotate {
		if backend.FileConfig.RotateConfig == nil {
			return nil, fmt.Errorf("rotate enabled but no field named 'rotate_config'")
		}
		iof = &lumberjack.Logger{
			Filename:   backend.FileConfig.Filename,
			MaxSize:    backend.FileConfig.RotateConfig.MaxSize,
			MaxAge:     backend.FileConfig.RotateConfig.MaxAge,
			MaxBackups: backend.FileConfig.RotateConfig.MaxBackups,
			LocalTime:  backend.FileConfig.RotateConfig.LocalTime,
			Compress:   backend.FileConfig.RotateConfig.Compress,
		}
	} else {
		var err error
		iof, err = os.OpenFile(backend.FileConfig.Filename, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0644)
		if err != nil {
			return nil, err
		}
	}
	if backend.FileConfig.FVConsole {
		return NewSimpleConsoleBackend(iof), nil
	}
	return hiedabke_writer.NewHiedaBackendWriter(iof), nil
}

func (hyu *HiedaLogYamlUtil) parseAlislsBackend(backend CommonLogConfigYAML_Backend) (hiedalog.HiedaLogBackend, error) {
	if backend.AliSLSConfig == nil {
		return nil, fmt.Errorf("no field named 'alisls_config' for backend type 'alisls'")
	}
	bac := backend.AliSLSConfig
	var srcip string
	if bac.OverrideWithRealIP {
		rip, err := getInternetIP()
		if err != nil {
			srcip = bac.EmitIP
		} else {
			srcip = rip
		}
	} else {
		srcip = bac.EmitIP
	}
	alicfg := hiedabke_alisls.AliSLSConfig{
		DebugMode:       bac.EnableAliSLSProducerDebug,
		AccessKeyID:     bac.Appkey,
		AccessKeySecret: bac.Secret,
		Endpoint:        bac.Endpoint,
		Project:         bac.Project,
		Logstore:        bac.Logstore,
		Topic:           bac.Topic,
		Hostname:        bac.Hostname,
		AppName:         bac.AppName,
		SourceIP:        srcip,
	}
	var aliextcfg *hiedabke_alisls.AliSLSConfigExtend
	if bac.ExtendAliSLSConfig == nil {
		aliextcfg = nil
	} else {
		aec := bac.ExtendAliSLSConfig
		aliextcfg = &hiedabke_alisls.AliSLSConfigExtend{
			TotalSizeLnBytes:      aec.TotalSizeLnBytes,
			MaxIoWorkerCount:      aec.MaxIoWorkerCount,
			MaxBlockSec:           aec.MaxBlockSec,
			MaxBatchSize:          aec.MaxBatchSize,
			MaxBatchCount:         aec.MaxBatchCount,
			LingerMs:              aec.LingerMs,
			Retries:               aec.Retries,
			MaxReservedAttempts:   aec.MaxReservedAttempts,
			BaseRetryBackoffMs:    aec.BaseRetryBackoffMs,
			MaxRetryBackoffMs:     aec.MaxRetryBackoffMs,
			AdjustShargHash:       aec.AdjustShargHash,
			Buckets:               aec.Buckets,
			AllowLogLevel:         aec.AllowLogLevel,
			LogFileName:           aec.LogFileName,
			IsJsonType:            aec.IsJsonType,
			LogMaxSize:            aec.LogMaxSize,
			LogMaxBackups:         aec.LogMaxBackups,
			LogCompress:           aec.LogCompress,
			NoRetryStatusCodeList: aec.NoRetryStatusCodeList,
		}
	}
	ah := hiedabke_alisls.NewHiedaBackendAliSLS(alicfg, aliextcfg)
	hyu.alisls_bknlist = append(hyu.alisls_bknlist, ah)
	return ah, nil
}

func getInternetIP() (string, error) {
	return "", fmt.Errorf("not supported yet")
}

type HiedaLogYamlUtil struct {
	alisls_bknlist []*hiedabke_alisls.HiedaBackendAliSLS
	Logger         *hiedalog.HiedaLogger
	AddedBackends  map[string]hiedalog.HiedaLogBackend
}

func (hyu *HiedaLogYamlUtil) StartAliSLS() {
	for _, v := range hyu.alisls_bknlist {
		v.StartProducer()
	}
}

func (hyu *HiedaLogYamlUtil) SafeShutdown() {
	for _, v := range hyu.alisls_bknlist {
		v.SafeStopProducer()
	}
}

func (hyu *HiedaLogYamlUtil) Shutdown(timeout_ms int64) error {
	for _, v := range hyu.alisls_bknlist {
		err := v.StopProducer(timeout_ms)
		if err != nil {
			return err
		}
	}
	return nil
}

type addInfo struct {
	Name    string
	Backend hiedalog.HiedaLogBackend
	Level   uint8
}

func CreateHiedaLoggerFromYAMLData(cfgdata CommonLogConfigYAML, autoStartAliSLS bool) (*HiedaLogYamlUtil, error) {
	hyu := &HiedaLogYamlUtil{
		Logger:         hiedalog.NewHiedaLogger(),
		alisls_bknlist: make([]*hiedabke_alisls.HiedaBackendAliSLS, 0),
		AddedBackends:  make(map[string]hiedalog.HiedaLogBackend),
	}
	if cfgdata.Enable {
		if cfgdata.Backends != nil {
			for k, v := range cfgdata.Backends {
				lvi := hyu.Logger.LevelFilter.NameToID(v.Level)
				if lvi == 7 {
					return nil, fmt.Errorf("unsupported log level '%s' in backend '%s'", v.Level, k)
				}
				var cins hiedalog.HiedaLogBackend
				var err error
				switch v.Type {
				case "console":
					cins, err = hyu.parseConsoleBackend(v)
				case "file":
					cins, err = hyu.parseFileBackend(v)
				case "alisls":
					cins, err = hyu.parseAlislsBackend(v)
				default:
					return nil, fmt.Errorf("unsupported log backend type '%s' in backend '%s'", v.Type, k)
				}
				if err != nil {
					return nil, err
				}
				hyu.Logger.AddBackend(cins, lvi)
				hyu.AddedBackends[k] = cins
			}
		}
	}
	if autoStartAliSLS {
		hyu.StartAliSLS()
	}
	return hyu, nil
}

func AddBackendsFromYAMLDataWithExistedLogger(logger *hiedalog.HiedaLogger, cfgdata CommonLogConfigYAML, autoStartAliSLS bool, clearExistBackends bool) (*HiedaLogYamlUtil, error) {
	hyu := &HiedaLogYamlUtil{
		Logger:         logger,
		alisls_bknlist: make([]*hiedabke_alisls.HiedaBackendAliSLS, 0),
		AddedBackends:  make(map[string]hiedalog.HiedaLogBackend),
	}
	if cfgdata.Enable {
		if cfgdata.Backends != nil {
			addlist := make([]*addInfo, 0)
			for k, v := range cfgdata.Backends {
				lvi := hyu.Logger.LevelFilter.NameToID(v.Level)
				if lvi == 7 {
					return nil, fmt.Errorf("unsupported log level '%s' in backend '%s'", v.Level, k)
				}
				var cins hiedalog.HiedaLogBackend
				var err error
				switch v.Type {
				case "console":
					cins, err = hyu.parseConsoleBackend(v)
				case "file":
					cins, err = hyu.parseFileBackend(v)
				case "alisls":
					cins, err = hyu.parseAlislsBackend(v)
				default:
					return nil, fmt.Errorf("unsupported log backend type '%s' in backend '%s'", v.Type, k)
				}
				if err != nil {
					return nil, err
				}
				addlist = append(addlist, &addInfo{
					Name:    k,
					Backend: cins,
					Level:   lvi,
				})
			}
			if clearExistBackends {
				hyu.Logger.BackendConfigs = make([]hiedalog.HiedaLogBackendConfig, 0)
			}
			for _, v := range addlist {
				hyu.Logger.AddBackend(v.Backend, v.Level)
				hyu.AddedBackends[v.Name] = v.Backend
			}
		}
	}
	if autoStartAliSLS {
		hyu.StartAliSLS()
	}
	return hyu, nil
}