파일에 로그를 쓰는 방법

Go로 로그 파일에 쓰려고합니다.

나는 여러 가지 접근법을 시도했지만 모두 실패했습니다. 이것이 내가 시도한 것입니다.

func TestLogging(t *testing.T) {
    if !FileExists("logfile") {
        CreateFile("logfile")
    }
    f, err := os.Open("logfile")
    if err != nil {
        t.Fatalf("error: %v", err)
    }

    // attempt #1
    log.SetOutput(io.MultiWriter(os.Stderr, f))
    log.Println("hello, logfile")

    // attempt #2
    log.SetOutput(io.Writer(f))
    log.Println("hello, logfile")

    // attempt #3
    log.SetOutput(f)
    log.Println("hello, logfile")
}

func FileExists(name string) bool {
    if _, err := os.Stat(name); err != nil {
       if os.IsNotExist(err) {
            return false
        }
    }
    return true
}

func CreateFile(name string) error {
    fo, err := os.Create(name)
    if err != nil {
        return err
    }
    defer func() {
        fo.Close()
    }()
    return nil
}

로그 파일이 생성되지만 아무것도 인쇄되거나 추가되지 않습니다. 왜?

os.Open() 과거에는 다르게 작동 했음에 틀림없지 만 이것은 나를 위해 작동합니다.

f, err := os.OpenFile("testlogfile", os.O_RDWR | os.O_CREATE | os.O_APPEND, 0666)
if err != nil {
    log.Fatalf("error opening file: %v", err)
}
defer f.Close()

log.SetOutput(f)
log.Println("This is a test log entry")

Go 문서에 따르면 "읽기 용"파일이 열리기 때문에 에서 os.Open()사용할 수 없습니다 log.SetOutput.

func Open

func Open(name string) (file *File, err error) Open읽기 위해 명명 된 파일을 엽니 다. 성공하면 반환 된 파일의 메서드를 사용하여 읽을 수 있습니다. 연관된 파일 설명자에는 mode가 있습니다 O_RDONLY. 오류가있는 경우 유형이 *PathError됩니다.

편집하다

확인 defer f.Close()후 이동if err != nil

로깅을위한 12 단계 앱 권장 사항의 단순성과 유연성을 선호합니다. 로그 파일에 추가하려면 셸 리디렉션을 사용할 수 있습니다. Go의 기본 로거는 stderr (2)에 기록합니다.

./app 2>> logfile

참조 : http://12factor.net/logs

나는 보통 화면에 로그를 인쇄하고 파일에도 씁니다. 이것이 누군가를 돕기를 바랍니다.

f, err := os.OpenFile("/tmp/orders.log", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
    log.Fatalf("error opening file: %v", err)
}
defer f.Close()
wrt := io.MultiWriter(os.Stdout, f)
log.SetOutput(wrt)
log.Println(" Orders API Called")

이것은 나를 위해 작동합니다

1. logger.go라는 패키지를 만들었습니다.

   package logger
   
   import (
     "flag"
     "os"
     "log"
     "go/build"
   )
   
   var (
     Log      *log.Logger
   )
   
   
   func init() {
       // set location of log file
       var logpath = build.Default.GOPATH + "/src/chat/logger/info.log"
   
      flag.Parse()
      var file, err1 = os.Create(logpath)
   
      if err1 != nil {
         panic(err1)
      }
         Log = log.New(file, "", log.LstdFlags|log.Lshortfile)
         Log.Println("LogFile : " + logpath)
   }

   2. 로그하려는 위치에 패키지를 가져옵니다 (예 : main.go).

      package main
      
      import (
         "logger"
      )
      
      const (
         VERSION = "0.13"
       )
      
      func main() {
      
          // time to use our logger, print version, processID and number of running process
          logger.Log.Printf("Server v%s pid=%d started with processes: %d", VERSION, os.Getpid(),runtime.GOMAXPROCS(runtime.NumCPU()))
      
      }

리눅스 머신에서 바이너리를 실행한다면 쉘 스크립트를 사용할 수 있습니다.

파일로 덮어 쓰기

./binaryapp > binaryapp.log

파일에 추가

./binaryapp >> binaryapp.log

stderr을 파일로 덮어 쓰기

./binaryapp &> binaryapp.error.log

파일에 stderr 추가

./binaryapp &>> binalyapp.error.log

쉘 스크립트 파일을 사용하면 더 동적 일 수 있습니다.

Go의 기본 로거는 stderr (2)에 기록합니다. 파일로 리디렉션

import ( 
    "syscall"
    "os" 
 )
func main(){
  fErr, err = os.OpenFile("Errfile", os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0600)
  syscall.Dup2(int(fErr.Fd()), 1) /* -- stdout */
  syscall.Dup2(int(fErr.Fd()), 2) /* -- stderr */

}

var필요한 경우 모든 프로세스가 액세스 할 수 있도록 전역에서 최상위를 선언하십시오 .

package main

import (
    "log"
    "os"
)
var (
    outfile, _ = os.Create("path/to/my.log") // update path for your needs
    l      = log.New(outfile, "", 0)
)

func main() {
    l.Println("hello, log!!!")
}

Allison과 Deepak의 대답을 바탕으로 저는 logrus를 사용하기 시작했고 정말 좋아했습니다.

var log = logrus.New()

func init() {

    // log to console and file
    f, err := os.OpenFile("crawler.log", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
    if err != nil {
        log.Fatalf("error opening file: %v", err)
    }
    wrt := io.MultiWriter(os.Stdout, f)

    log.SetOutput(wrt)
}

주 함수에 지연 f.Close ()가 있습니다.

매일 생성되는 파일에 로그를 작성하고 있습니다 (하루에 하나의 로그 파일이 생성됨). 이 접근 방식은 저에게 잘 작동합니다.

var (
    serverLogger *log.Logger
)

func init() {
    // set location of log file
    date := time.Now().Format("2006-01-02")
    var logpath = os.Getenv(constant.XDirectoryPath) + constant.LogFilePath + date + constant.LogFileExtension
    os.MkdirAll(os.Getenv(constant.XDirectoryPath)+constant.LogFilePath, os.ModePerm)
    flag.Parse()
    var file, err1 = os.OpenFile(logpath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)

    if err1 != nil {
        panic(err1)
    }
    mw := io.MultiWriter(os.Stdout, file)
    serverLogger = log.New(mw, constant.Empty, log.LstdFlags)
    serverLogger.Println("LogFile : " + logpath)
}

// LogServer logs to server's log file
func LogServer(logLevel enum.LogLevel, message string) {
    _, file, no, ok := runtime.Caller(1)
    logLineData := "logger_server.go"
    if ok {
        file = shortenFilePath(file)
        logLineData = fmt.Sprintf(file + constant.ColonWithSpace + strconv.Itoa(no) + constant.HyphenWithSpace)
    }
    serverLogger.Println(logLineData + logLevel.String() + constant.HyphenWithSpace + message)
}

// ShortenFilePath Shortens file path to a/b/c/d.go tp d.go
func shortenFilePath(file string) string {
    short := file
    for i := len(file) - 1; i > 0; i-- {
        if file[i] == constant.ForwardSlash {
            short = file[i+1:]
            break
        }
    }
    file = short
    return file
}

파일의 전체 경로에서 파일 이름을 가져 오는 데 사용되는 "shortenFilePath ()"메서드입니다. 및 "LogServer ()"메서드는 형식화 된 로그 문을 만드는 데 사용됩니다 (파일 이름, 줄 번호, 로그 수준, 오류 문 등 포함).

다른 사람들을 돕기 위해 두 경우 모두 로깅을 처리하는 기본 로그 함수를 만듭니다. 출력을 stdout으로 설정 한 다음 디버그를 켜면 바로 출력을 선택할 수 있도록 스위치 플래그를 수행 할 수 있습니다.

func myLog(msg ...interface{}) {
    defer func() { r := recover(); if r != nil { fmt.Print("Error detected logging:", r) } }()
    if conf.DEBUG {
        fmt.Println(msg)
    } else {
        logfile, err := os.OpenFile(conf.LOGDIR+"/"+conf.AppName+".log", os.O_RDWR | os.O_CREATE | os.O_APPEND,0666)
        if !checkErr(err) {
            log.SetOutput(logfile)
            log.Println(msg)
        }
        defer logfile.Close()
    }
}

아마도 이것은 당신을 도울 것입니다 (로그 파일이 존재한다면 그것을 사용하고 존재하지 않는다면 그것을 만드십시오) :

package main

import (
    "flag"
    "log"
    "os"
)
//Se declara la variable Log. Esta será usada para registrar los eventos.
var (
    Log *log.Logger = Loggerx()
)

func Loggerx() *log.Logger {
    LOG_FILE_LOCATION := os.Getenv("LOG_FILE_LOCATION")
        //En el caso que la variable de entorno exista, el sistema usa la configuración del docker.
    if LOG_FILE_LOCATION == "" {
        LOG_FILE_LOCATION = "../logs/" + APP_NAME + ".log"
    } else {
        LOG_FILE_LOCATION = LOG_FILE_LOCATION + APP_NAME + ".log"
    }
    flag.Parse()
        //Si el archivo existe se rehusa, es decir, no elimina el archivo log y crea uno nuevo.
    if _, err := os.Stat(LOG_FILE_LOCATION); os.IsNotExist(err) {
        file, err1 := os.Create(LOG_FILE_LOCATION)
        if err1 != nil {
            panic(err1)
        }
                //si no existe,se crea uno nuevo.
        return log.New(file, "", log.Ldate|log.Ltime|log.Lshortfile)
    } else {
                //si existe se rehusa.
        file, err := os.OpenFile(LOG_FILE_LOCATION, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0666)
        if err != nil {
            panic(err)
        }
        return log.New(file, "", log.Ldate|log.Ltime|log.Lshortfile)
    }
}

자세한 내용 : https://su9.co/9BAE74B