// initLog initializes an event logger. It registers the source name with // the registry if it does not already exist. func initLog(provider, source, msgFile string) (*elog.Log, error) { // Install entry to registry: _, err := elog.Install(providerName, sourceName, msgFile, true, allLevels) if err != nil { return nil, err } // Open a new logger for writing events: log, err := elog.Open(sourceName) if err != nil { var errs multierror.Errors errs = append(errs, err) err := elog.RemoveSource(providerName, sourceName) if err != nil { errs = append(errs, err) } err = elog.RemoveProvider(providerName) if err != nil { errs = append(errs, err) } return nil, errs.Err() } return log, nil }
func TestLog(t *testing.T) { if testing.Short() { t.Skip("skipping test in short mode - it modifies system logs") } const name = "mylog" const supports = eventlog.Error | eventlog.Warning | eventlog.Info | eventlog.Success | eventlog.AuditSuccess | eventlog.AuditFailure alreadyExists, err := eventlog.InstallAsEventCreate(eventlog.Application, name, supports) if err != nil { t.Fatalf("Install failed: %s", err) } t.Log("Already exists:", alreadyExists) defer func() { err = eventlog.RemoveSource(eventlog.Application, name) if err != nil { t.Fatalf("Remove failed: %s", err) } }() l, err := eventlog.Open(name) if err != nil { t.Fatalf("Open failed: %s", err) } defer l.Close() err = l.Success(1, "success") if err != nil { t.Fatalf("Successo failed: %s", err) } err = l.Info(2, "info") if err != nil { t.Fatalf("Info failed: %s", err) } err = l.Warning(3, "warning") if err != nil { t.Fatalf("Warning failed: %s", err) } err = l.Error(4, "error") if err != nil { t.Fatalf("Error failed: %s", err) } err = l.AuditSuccess(5, "audit success") if err != nil { t.Fatalf("AuditSuccess failed: %s", err) } err = l.AuditFailure(6, "audit failure") if err != nil { t.Fatalf("AuditFailure failed: %s", err) } }
// Initializes logp if the verbose flag was set. func configureLogp() { oneTimeLogpInit.Do(func() { if testing.Verbose() { logp.LogInit(logp.LOG_DEBUG, "", false, true, []string{"eventlog"}) logp.Info("DEBUG enabled for eventlog.") } else { logp.LogInit(logp.LOG_WARNING, "", false, true, []string{}) } // Clear the event log before starting. log, _ := elog.Open(sourceName) eventlogging.ClearEventLog(eventlogging.Handle(log.Handle), "") log.Close() }) }
func main() { flag.Parse() if *install { err := registerSource(*provider, *source) if err != nil { fmt.Fprintln(os.Stderr, err) os.Exit(1) } return } if *file == "" { fmt.Fprintln(os.Stderr, "-f is required") flag.Usage() os.Exit(1) } // Open a handle to the event log. log, err := eventlog.Open(*log) if err != nil { fmt.Fprintln(os.Stderr, "opening eventlog:", err) os.Exit(1) } // Open the file on disk. file, err := os.Open(*file) if err != nil { fmt.Fprintln(os.Stderr, "opening file:", err) os.Exit(1) } defer file.Close() eg := &eventgen{ file: file, max: uint32(*max), done: make(chan struct{}), log: log, } eg.installSignalHandler() // Rate limit writing using a token bucket. if *rate != 0 { eg.tb = ratelimit.NewBucketWithRate(*rate, int64(math.Ceil(*rate))) eg.tb.TakeAvailable(eg.tb.Available()) } else if *interval != 0 { eg.tb = ratelimit.NewBucket(*interval, 1) eg.tb.TakeAvailable(eg.tb.Available()) } start := time.Now() // Start a new worker to read lines from the file. wg := &sync.WaitGroup{} wg.Add(1) go eg.reportEvents(wg) wg.Wait() elapsed := time.Since(start) fmt.Println("elapsed time:", elapsed) fmt.Println("event count:", atomic.LoadUint32(&eg.count)) }