# learn_go

**Repository Path**: jellyfish/learn_go

## Basic Information

- **Project Name**: learn_go
- **Description**: No description available
- **Primary Language**: Go
- **License**: MIT
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2018-09-03
- **Last Updated**: 2021-11-03

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

```
package log

import (
	"fmt"
	"github.com/micro/go-config"
	"github.com/micro/go-config/source"
	"github.com/micro/go-config/source/file"
	"learn_go/zap/zlog/zap"
	"learn_go/zap/zlog/zap/zapcore"
	"os"
	"strings"
)

type WatchConfig struct {
	Level      string                 `json:"level" default:"debug"`
	InitFields map[string]interface{} `json:"init_fields"`
}

var sugar *zap.SugaredLogger
var logger *zap.Logger
var alevel zap.AtomicLevel

func Sugar() *zap.SugaredLogger {
	return sugar
}

func Logger() *zap.Logger {
	return logger
}

func SetLevel(level string) {
	l := strings.ToLower(level)
	if l == "info" {
		alevel.SetLevel(zap.InfoLevel)
	} else if l == "debug" {
		alevel.SetLevel(zap.DebugLevel)
	} else if l == "error" {
		alevel.SetLevel(zap.ErrorLevel)
	} else if l == "warn" {
		alevel.SetLevel(zap.WarnLevel)
	}
}

type K8s struct {
	Namespace string
	Name      string
}

type File struct {
	Path string
}

func InitFile(changeCallback func(*WatchConfig), filename string) error {
	return initSources(changeCallback, File{filename})
}

func initSources(changeCallback func(*WatchConfig), src ...interface{}) error {
	sourceList := make([]source.Source, 0)
	for _, s := range src {
		switch v := s.(type) {
		case File:
			sourceList = append(sourceList, file.NewSource(
				file.WithPath(v.Path),
			))
		case K8s:
			// need download k8s package
			//sourceList = append(sourceList, configmap.NewSource(
			//	configmap.WithNamespace(v.Namespace),
			//	configmap.WithName(v.Name), )
			return fmt.Errorf("k8s not supported Now")
		default:
			return fmt.Errorf("%v not supported now", s)
		}
		fmt.Println(s)
	}
	return initialize("watch", changeCallback, sourceList...)
}

func initZap(level string, initFields map[string]interface{}) error {
	var opts []zap.Option
	opts = append(opts, zap.Development())
	opts = append(opts, zap.AddCaller())
	stackLevel := zap.ErrorLevel
	opts = append(opts, zap.AddStacktrace(stackLevel))

	encodeConfig := zapcore.EncoderConfig{
		TimeKey:        "time",
		LevelKey:       "level",
		NameKey:        "logger",
		CallerKey:      "caller",
		MessageKey:     "msg",
		StacktraceKey:  "stacktrace",
		LineEnding:     zapcore.DefaultLineEnding,
		EncodeLevel:    zapcore.LowercaseLevelEncoder,
		EncodeTime:     zapcore.ISO8601TimeEncoder,
		EncodeDuration: zapcore.SecondsDurationEncoder,
		EncodeCaller:   zapcore.ShortCallerEncoder,
	}

	consoleEncoder := zapcore.NewConsoleEncoder(encodeConfig)
	consoleDebugging := zapcore.Lock(os.Stdout)

	alevel = zap.NewAtomicLevel()
	SetLevel(level)

	core := zapcore.NewTee(
		zapcore.NewCore(consoleEncoder, consoleDebugging, alevel),
	)

	logger = zap.New(core)
	if len(initFields) > 0 {
		initFieldList := make([]zap.Field, 0)
		for k, v := range initFields {
			initFieldList = append(initFieldList, zap.Any(k, v))
		}
		logger = logger.With(initFieldList...)
	}

	logger = logger.WithOptions(opts...)
	sugar = logger.Sugar()

	return nil
}

func initialize(watch string, changeCallback func(*WatchConfig), sourceList ...source.Source) error {
	err := config.Load(sourceList...)
	if err != nil {
		return err
	}

	watchConfig := new(WatchConfig)
	err = config.Get(watch).Scan(watchConfig)
	if err != nil {
		return err
	}

	// init watch
	watcher, err := config.Watch(watch)
	if err != nil {
		fmt.Printf("watch error:%s", err.Error())
		panic(err)
	}

	go func() {
		for {
			v, err := watcher.Next()
			if err == nil {
				obj := new(WatchConfig)
				v.Scan(obj)
				changeCallback(obj)
			}
		}
	}()

	// init zap
	return initZap(watchConfig.Level, watchConfig.InitFields)
}

```

go module

https://studygolang.com/articles/14625?fr=sidebar


环境变量设置
export GO111MODULE=on
go mod init learn_go/zap