Aller: Désactiver un journal.Enregistreur?

J'ai quelques lourdement instrumentés de code qui rend l'utilisation de la log paquet. Maintenant, il est venu le temps pour désactiver la journalisation, et je ne peux pas savoir comment désactiver l'enregistrement standard.

Ai-je raté quelque chose? Dois-je vérifier un drapeau avant de faire des appels du journal, ou de faire des commentaires dans la production?

InformationsquelleAutor Matt Joiner | 2012-05-13

flags go logging

Pour désactiver complètement les journaux, c'est effectivement mieux d'appeler log.SetFlags(0)^Joril et la sortie no-op io.Writer (c'est à dire, log.SetOutput(ioutil.Discard))

Mais même après cela, les opérations de ralenti autour de De 500 à 600 ns/op¹

Cela peut encore être coupés courts (autour de 100 ns/op) à l'aide d'un custom Logger mise en œuvre, et la mise en œuvre de toutes les fonctions non-op -- comme l'a démontré ici (seulement primordial Println pour bervity).

Alternative à toutes ces est d'utiliser un custom de journalisation des niveaux et le jeu à remplir OFF.

Noter cependant, l'un des les plus couramment utilisés de la bibliothèque pour l'enregistrement (logrus) a les conséquences de performance -- la même chose peut être trouvé dans la repères où il effectuer avec 3K+ ns/op, peu importe.

Opinion biaisée: à partir de repères, la bibliothèque aller de l'enregistrement de effectue dans le par la coutume Logger mise en œuvre de la Level à -1, quel que soit le backend et le formatage

(la source de référence peut être trouvé ici)

la sortie de l'indice de référence est la suivante:

testing: warning: no tests to run
PASS
BenchmarkGoLogging-4                                             1000000          2068 ns/op
BenchmarkGoLoggingNullBackend-4                                  5000000           308 ns/op
BenchmarkGoLoggingNullBackendWithFancyFormatter-4                3000000           435 ns/op
BenchmarkGoLoggingOffLevel-4                                    20000000           109 ns/op
BenchmarkGoLoggingNullBackendAndOffLevel-4                      20000000           108 ns/op
BenchmarkGoLoggingNullBackendWithFancyFormatterAndOffLevel-4    20000000           109 ns/op
BenchmarkLog15-4                                                  200000          7359 ns/op
BenchmarkLog15WithDiscardHandler-4                               2000000           922 ns/op
BenchmarkLog15WithDiscardHandlerAndOffLevel-4                    2000000           926 ns/op
BenchmarkLog15WithNopLogger-4                                   20000000           108 ns/op
BenchmarkLog15WithNopLoggerDiscardHandlerA-4                    20000000           112 ns/op
BenchmarkLog15WithNopLoggerAndDiscardHandlerAndOffLevel-4       20000000           112 ns/op
BenchmarkLog-4                                                   1000000          1217 ns/op
BenchmarkLogIoDiscardWriter-4                                    2000000           724 ns/op
BenchmarkLogIoDiscardWriterWithoutFlags-4                        3000000           543 ns/op
BenchmarkLogCustomNullWriter-4                                   2000000           731 ns/op
BenchmarkLogCustomNullWriterWithoutFlags-4                       3000000           549 ns/op
BenchmarkNopLogger-4                                            20000000           113 ns/op
BenchmarkNopLoggerWithoutFlags-4                                20000000           112 ns/op
BenchmarkLogrus-4                                                 300000          3832 ns/op
BenchmarkLogrusWithDiscardWriter-4                                500000          3032 ns/op
BenchmarkLogrusWithNullFormatter-4                                500000          3814 ns/op
BenchmarkLogrusWithPanicLevel-4                                   500000          3872 ns/op
BenchmarkLogrusWithDiscardWriterAndPanicLevel-4                   500000          3085 ns/op
BenchmarkLogrusWithDiscardWriterAndNullFormatterAndPanicLevel-4   500000          3064 ns/op
ok      log-benchmarks  51.378s
go test -bench .  62.17s user 3.90s system 126% cpu 52.065 total

^{#1: YMMV, testé sur i7-4500U CPU @ 1.80 GHz}

La réponse est quelque peu dépassées. Les processeurs sont différents, Golang est différent. Vous pouvez faire de mieux que de 15 ns/opération dans Golang avec un journal personnalisé. C'est un simple POC de log binaire github.com/larytet/binlog Lors de la sortie seulement partie intégrante des types il frappe de 30 à 40 ns/op gamme
sentez-vous libre pour modifier la réponse à de nouvelles informations (ou ajouter un nouvel élément de réponse). La référence est censé donner une juste idée de la performance de chaque w.r.t les uns des autres; pas de w.r.t de la CPU et de Golang version. Il peut y avoir de nouvelles bibliothèques plus efficace (comme il faut), je ne peut pas suivre chacun d'eux. Car la source de la référence est donnée, je suppose que le lecteur de faire cette comparaison pour eux-mêmes (depuis presque toujours YMMV).
Avinash R, le nombre indiqué 500ns/op n'est pas représentatif de l'état actuel de l'art. Voir, par exemple, github.com/PlatformLab/NanoLog - c'est un sous 10ns journal.

InformationsquelleAutor Avinash R

104

Pas de raison de créer votre propre type de commune io.Auteur quand il en existe un dans l'io/ioutil paquet.
```
import (
"log"
"io/ioutil"
)
func init() {
log.SetOutput(ioutil.Discard)
}
```
- Super trouvaille! J'ai regardé pour une telle chose dans les bibliothèques standard, mais n'a pas vérifier io/ioutil.
- Sera-ce de désactiver l'enregistreur de données que pour l'emballage, ou l'ensemble de l'application?
- Depuis cette saute d'écriture sur le disque, mais n'a toujours toute la mise en forme, un appel à log.SetFlags(0) devrait la soulager un peu, je pense
- C'est vraiment agréable d'avoir lorsque vous avez besoin de supprimer la journalisation pour les tests de référence. Était sur le point de se moquer de mon propre enregistreur avant je suis tombé sur cette.
InformationsquelleAutor Jeff Wendling
6
```
type NullWriter int
func (NullWriter) Write([]byte) (int, error) { return 0, nil }
//...
log.SetOutput(new(NullWriter))
```
- Pourrait-ce être le cas que certains utilisateurs de l'Écrivain va tenter de continuer à écrire si le int valeur de retour est 0? (c'est à dire peut-être devrions-nous retourner len(b) lorsque l'argument est b []byte?)
- Généralement, vous avez raison, mais log paquet ignore int valeur de retour, nous avons donc préférable de ne pas perdre de temps dans une telle fréquente de la fonction dans le code de production.
- Est-il des meilleures pratiques sur l'utilisation de log en Aller? Sont la plupart de la journalisation des appels finalement retiré (ou en commentaire) si ils sont à des fins de traçabilité?
- Aller pour le moment, mais avez-vous vu ceci?
- nice de ramassage! 🙂
- Je ne garde pas la journalisation des appels pour les tests. Les retirer dès que je n'ai pas besoin d'eux. Mais vous pouvez avoir plusieurs enregistreurs en Aller. D'habitude, j'ai deux: infoLogger et errLogger, et ce, à des produits adaptés au développement et à la production (en utilisant les options de ligne de commande). Vous pouvez en avoir une autre, debugLogger ou quelque chose comme ça, et de le désactiver dans la production.
- ce n'est pas une bonne façon de le faire comme il fait tout le travail de mise en forme de la sortie, que pour détruire. si vous voulez la journalisation des appels que vous pouvez désactiver, c'est mieux pour endiguer le flux à la source, en évitant l'appel à journaux.Printf.
InformationsquelleAutor Mostafa
3

Cette approche permet à la désactivation de la journalisation à l'exécution:
```
type LogWriter struct{
enabled bool
}
func (l *LogWriter) Enable() {
l.enabled = true
}
func (l *LogWriter) Disable() {
l.enabled = false
}
func (l *LogWriter) Write([]byte) (int, error) {
if l.enabled {
//...
}
return 0, nil
}
```
Et cette approche permet d'activer ou de désactiver l'enregistrement pour l'ensemble de l'exécution:
```
type LogWriter struct{}
func (l *LogWriter) Write([]byte) (int, error) {
if some.Constant {
//...
}
return 0, nil
}
```
_{Où some.Constant serait une constante que vous définissez avant la compilation (la production d'un "production" binaire) ou une variable qui est définie une seule fois lors de l'exécution du programme via les options de ligne de commande (quelque chose comme myprogram --enable-logging=true)}

Avec les deux approches, vous pouvez laisser votre code actuel, presque entièrement intacte.

InformationsquelleAutor thwd
2

Depuis SetOutput() n'est définie pour le mondial de l'enregistreur, une coutume de l'écrivain est toujours utile pour d'autres enregistreurs. Un court chemin de l'écriture est comme ceci:
```
type LogWriter struct{ io.Writer }
func (w *LogWriter) Enable()  { w.Writer = os.Stdout }
func (w *LogWriter) Disable() { w.Writer = ioutil.Discard }
```
InformationsquelleAutor TJM
1

Une note pour les autres à venir ici à la recherche de ce et d'autres fonctionnalités de journalisation: jetez un oeil à la log4go package en tant que couvre la désactivation de la journalisation, la définition de niveaux de journal, journal de rotation, la redirection vers un fichier, etc qui pourraient être utiles.

Voir le doc à http://godoc.org/code.google.com/p/log4go

InformationsquelleAutor Kenny Grant

Vous devez vous connecter pour publier un commentaire.