Aller/Golang écriture du journal de fichier

Je suis en train d'écrire dans un fichier journal avec Golang.

J'ai essayé plusieurs approches, qui ont toutes échoué. C'est ce que j'ai essayé:

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
}

Le fichier journal est créé, mais rien n'est jamais imprimé ou ajouté à la fin. Pourquoi?

Si vous déployez votre programme sous Linux, vous pouvez simplement écrire votre journal à std sortie de rediriger la sortie vers un fichier comme ceci: ./programme 2>,&1 | tee logs.txt. Il doit y avoir une autre façon dans un autre système.

InformationsquelleAutor Allison A | 2013-11-13

go logging

137

os.Open() doit avoir travaillé différemment dans le passé, mais cela fonctionne pour moi:
```
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")
```
Basé sur l'Aller docs, os.Open() ne peut pas travailler pour log.SetOutput, parce qu'il ouvre le fichier pour la lecture:"

func Open

func Open(name string) (file *File, err error) Open ouvre le nommé
fichier pour la lecture. En cas de succès, les méthodes sur le fichier renvoyé peut être
utilisé pour la lecture; le descripteur de fichier associé a mode O_RDONLY. Si
il y a une erreur, il sera de type *PathError.

MODIFIER

Déplacé defer f.Close() après if err != nil vérifier
- Ne pas reporter la Fermer avant de vérifier tre nul!
- Ce n'est pas l'activité en fait dangereux pour fermer dans tous les cas, iirc. Ce n'est pas vrai pour tous les types.
- peut-être nil, qui pourraient résulter d'un mouvement de panique. Donc la vérification de err avant de reporter l'appel est conseillé.
- soin d'expliquer pourquoi Open ne fonctionne pas avec les log.SetOutput?
- parce que les os.Open() est O_RDONLY (readonly curseur), et pour le connecter à écrire, il doit être accessible en écriture. RE le reporter, j'ai été en supposant que si err n'était pas nul, que f peut encore avoir une valeur, n'est-ce pas vrai?
- ah, désolé, incontournable de la lecture seule de la partie, maintenant il prend tout son sens :). Re. reporter, il est courant de retour d'un néant valeur lorsqu'une erreur se produit car il est souvent impossible de retourner un objet valide (en raison de l'erreur). Si vous ne pouvez pas compter sur l'appel de quoi que ce soit sur la valeur retournée lorsque l'erreur est non-nulle.
- Le plus sûr autorisations sont 0644 ou même 0664 pour permettre à l'utilisateur de lire/écrire, d'utilisateur et de groupe de lecture/écriture, et dans les deux cas, d'interdire à tout le monde de l'écriture.
InformationsquelleAutor Allison A
23

Je préfère la simplicité et la flexibilité de l'12 facteur d'application de la recommandation pour la journalisation. Pour ajouter un fichier journal, vous pouvez utiliser le shell de redirection. La valeur par défaut de l'enregistreur de à Aller de l'écrit sur la sortie stderr (2).
```
./app 2>> logfile
```
Voir aussi: http://12factor.net/logs
- ne sera pas une bonne pratique lorsque vous souhaitez daemonize choses, esp avec des start-tsop-démon
- Systemd pourrait facilement prendre soin de l'enregistrement, ainsi que sur les start-stop fonctions.
InformationsquelleAutor Philip Nelson

Cela fonctionne pour moi

créé un package appelé enregistreur.aller

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

importer le package partout où vous voulez vous connecter.e.g principal.aller

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

}

InformationsquelleAutor philip mudenyo

J'ai l'habitude d'imprimer les journaux sur l'écran et d'écrire dans un fichier en tant que bien. Espérons que cela aide quelqu'un.

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

InformationsquelleAutor deepakssn

La valeur par défaut de l'enregistreur de à Aller de l'écrit sur la sortie stderr (2).
rediriger vers un fichier

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

}

InformationsquelleAutor sergey

2

De déclarer haut dans votre global var de sorte que tous vos processus peut accéder si nécessaire.
```
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!!!")
}
```
- Ne pense pas que cela fonctionne...
- Hey @CostaHuang, merci de laisser des commentaires détaillés. Merci
- J'ai juste couru mon extrait de code et il fonctionne.
- Salut @openwonk, j'ai testé à nouveau et il ne fonctionne pas sur mon ordinateur. Ma version est go version go1.10.2 windows/amd64, quelle est la vôtre?
- J'ai juste couru exemple avec le même jeu que vous. L'exemple suppose que vous avez déjà un dossier structure mise en place. Il y a des moyens faciles pour vérifier cela, cependant mon but avec exemple est de montrer comment relativement simple écriture dans un fichier journal. Modifiez votre code pour outfile, _ = os.Create("my.log") et il fonctionnera comme prévu.
- Votre code fonctionne. J'ai été en utilisant outfile, _ = os.Create("./path/to/my.log"). J'avais en quelque sorte l'espoir que le code va créer le path/to dossiers et la my.log fichier, mais apparemment ça ne fonctionne pas. Je voudrais vous suggérer de modifier votre réponse à outfile, _ = os.Create("./my.log"). De cette façon, nous savons clairement que c'est de créer un journal dans le dossier en cours.
InformationsquelleAutor openwonk
1

Si vous exécutez binaire sur la machine linux vous pouvez utiliser un script shell.

écraser dans un fichier
```
./binaryapp > binaryapp.log
```
ajouter dans un fichier
```
./binaryapp >> binaryapp.log
```
remplacer stderr dans un fichier
```
./binaryapp &> binaryapp.error.log
```
ajouter stderr dans un fichier
```
./binaryapp &>> binalyapp.error.log
```
il peut être plus dynamique, à l'aide d'un script shell fichiers.
- Bon à savoir, comment pouvons-nous remplacer stderr pour vous connecter.
InformationsquelleAutor Adzimzf

Je suis en train d'écrire les logs pour les fichiers, qui sont de générer sur une base quotidienne (par jour un journal de fichier est généré). Cette approche fonctionne bien pour moi :

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()" méthode utilisée pour obtenir le nom du fichier chemin d'accès complet du fichier. et "serveur de log()" sert à créer un journal formaté déclaration (contient : le nom de fichier, numéro de ligne, le niveau de journal, erreur de déclaration, etc...)

InformationsquelleAutor Hardik Bohra

Vous devez vous connecter pour publier un commentaire.