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