LogDog: Add project namespace to Butler/Collector.

client/cmd/logdog_butler/main.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package main
 
 import (
         "errors"
         "flag"
         "fmt"
@@ skipping 85 matching lines @@
                 multiflag.HelpOption(&a.outputConfig.MultiFlag),
         }
 
         // Add registered conditional (build tag) options.
         for _, f := range getOutputFactories() {
                 a.outputConfig.AddFactory(f)
         }
 
         a.maxBufferAge = clockflag.Duration(butler.DefaultMaxBufferAge)
 
+        fs.Var(&a.butler.Project, "project",
+                "The log prefix's project name (required).")
         fs.Var(&a.butler.Prefix, "prefix",
                 "Prefix to apply to all stream names.")
         fs.Var(&a.outputConfig, "output",
                 "The output name and configuration. Specify 'help' for more information.")
         fs.StringVar(&a.cpuProfile,
                 "cpuprofile", "", "If specified, enables CPU profiling and profiles to the specified path.")
         fs.IntVar(&a.butler.OutputWorkers, "output-workers", butler.DefaultOutputWorkers,
                 "The maximum number of parallel output dispatches.")
         fs.Var(&a.maxBufferAge, "output-max-buffer-age",
                 "Send buffered messages if they've been held for longer than this period.")
@@ skipping 48 matching lines @@
 
         return output, nil
 }
 
 // An execution harness that adds application-level management to a Butler run.
 func (a *application) Main(runFunc func(b *butler.Butler) error) error {
         // Enable CPU profiling if specified
         if a.cpuProfile != "" {
                 f, err := os.Create(a.cpuProfile)
                 if err != nil {
-                        return fmt.Errorf("Failed to create CPU profile output: %v", err)
+                        return fmt.Errorf("failed to create CPU profile output: %v", err)
                 }
                 pprof.StartCPUProfile(f)
                 defer pprof.StopCPUProfile()
         }
 
+        // Generate a prefix secret for this Butler session.
+        var err error
+        if a.butler.Secret, err = types.NewPrefixSecret(); err != nil {
+                return fmt.Errorf("failed to generate prefix secret: %s", err)
+        }
+
         // Instantiate our Butler.
         a.butler.MaxBufferAge = time.Duration(a.maxBufferAge)
         a.butler.BufferLogs = !a.noBufferLogs
         a.butler.Output = a.output
         a.butler.TeeStdout = os.Stdout
         a.butler.TeeStderr = os.Stderr
         if err := a.butler.Validate(); err != nil {
                 return err
         }
 
@@ skipping 83 matching lines @@
         a.authFlags.Register(flags, authOptions)
 
         // Parse the top-level flag set.
         if err := flags.Parse(argv); err != nil {
                 log.WithError(err).Errorf(a, "Failed to parse command-line.")
                 return configErrorReturnCode
         }
 
         a.Context = logConfig.Set(a.Context)
 
+        // TODO(dnj): Force all invocations to supply a Project.
+        if a.butler.Project != "" {
+                if err := a.butler.Project.Validate(); err != nil {
+                        log.WithError(err).Errorf(a, "Invalid project (-project).")
+                        return configErrorReturnCode
+                }
+        }
+
         // Validate our Prefix; generate a user prefix if one was not supplied.
         prefix := a.butler.Prefix
         if prefix == "" {
                 // Auto-generate a prefix.
                 prefix, err := generateRandomUserPrefix(a)
                 if err != nil {
                         log.WithError(err).Errorf(a, "Failed to generate user prefix.")
                         return configErrorReturnCode
                 }
                 a.butler.Prefix = prefix
@@ skipping 62 matching lines @@
 
         paniccatcher.Do(func() {
                 rc = mainImpl(ctx, os.Args[1:])
         }, func(p *paniccatcher.Panic) {
                 log.Fields{
                         "panic.error": p.Reason,
                 }.Errorf(ctx, "Panic caught in main:\n%s", p.Stack)
                 rc = runtimeErrorReturnCode
         })
 }