Cách ghi nhật ký vào tệp

Tôi đang cố gắng ghi vào tệp nhật ký bằng Go.

Tôi đã thử một số cách tiếp cận, tất cả đều không thành công. Đây là những gì tôi đã thử:

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
}

Tệp nhật ký được tạo, nhưng không có gì được in hoặc thêm vào nó. Tại sao?

os.Open() chắc hẳn đã hoạt động khác trong quá khứ, nhưng điều này phù hợp với tôi:

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")

Dựa trên tài liệu Go, os.Open()không thể hoạt động log.SetOutputvì nó mở tệp "để đọc:"

func Open

func Open(name string) (file *File, err error) Openmở tệp đã đặt tên để đọc. Nếu thành công, các phương thức trên tệp trả về có thể được sử dụng để đọc; bộ mô tả tệp được liên kết có chế độ O_RDONLY. Nếu có lỗi sẽ bị loại *PathError.

BIÊN TẬP

Chuyển defer f.Close()đến sau khi if err != nilkiểm tra

Tôi thích sự đơn giản và linh hoạt của đề xuất ứng dụng 12 yếu tố để ghi nhật ký. Để thêm vào tệp nhật ký, bạn có thể sử dụng chuyển hướng trình bao. Trình ghi mặc định trong Go ghi vào stderr (2).

./app 2>> logfile

Xem thêm: http://12factor.net/logs

Tôi thường in nhật ký trên màn hình và viết thành tệp. Hy vọng điều này sẽ giúp ai đó.

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")

Điều này phù hợp với tôi

1. đã tạo một gói có tên 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. nhập gói bất cứ nơi nào bạn muốn đăng nhập, ví dụ: 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()))
      
      }

Nếu bạn chạy nhị phân trên máy linux, bạn có thể sử dụng tập lệnh shell.

ghi đè lên một tệp

./binaryapp > binaryapp.log

nối vào một tệp

./binaryapp >> binaryapp.log

ghi đè stderr vào một tệp

./binaryapp &> binaryapp.error.log

nối stderr vào một tệp

./binaryapp &>> binalyapp.error.log

nó có thể năng động hơn bằng cách sử dụng tệp kịch bản shell.

Trình ghi mặc định trong Go ghi vào stderr (2). chuyển hướng đến tệp

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 */

}

Khai báo hàng đầu trong toàn cầu của bạn varđể tất cả các quy trình của bạn có thể truy cập nếu cần.

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!!!")
}

Dựa trên câu trả lời của Allison và Deepak, tôi bắt đầu sử dụng logrus và thực sự thích nó:

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)
}

Tôi có một defer f.Close () trong hàm chính

Tôi đang ghi nhật ký vào các tệp, được tạo hàng ngày (mỗi ngày, một tệp nhật ký được tạo). Cách tiếp cận này đang hoạt động tốt đối với tôi:

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
}

Phương thức "shortFilePath ()" được sử dụng để lấy tên của tệp từ đường dẫn đầy đủ của tệp. và phương thức "LogServer ()" được sử dụng để tạo một câu lệnh nhật ký được định dạng (chứa: tên tệp, số dòng, cấp độ nhật ký, câu lệnh lỗi, v.v.)

Để giúp những người khác, tôi tạo một hàm nhật ký cơ bản để xử lý việc ghi nhật ký trong cả hai trường hợp, nếu bạn muốn đầu ra là ổn định, thì hãy bật gỡ lỗi, ngay lập tức nó sẽ thực hiện một cờ chuyển đổi để bạn có thể chọn đầu ra của mình.

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()
    }
}

có thể điều này sẽ giúp bạn (nếu tệp nhật ký tồn tại, hãy sử dụng nó, nếu nó không tồn tại, hãy tạo nó):

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)
    }
}

Để biết thêm chi tiết: https://su9.co/9BAE74B