Add profiling, integrate into Butler/Annotee.

logdog/client/cmd/logdog_annotee/main.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package main
 
 import (
         "encoding/json"
         "errors"
         "flag"
         "fmt"
         "os"
         "time"
 
         "github.com/golang/protobuf/proto"
         "github.com/luci/luci-go/common/clock/clockflag"
         "github.com/luci/luci-go/common/config"
         log "github.com/luci/luci-go/common/logging"
         "github.com/luci/luci-go/common/logging/gologger"
         "github.com/luci/luci-go/common/proto/milo"
+        "github.com/luci/luci-go/common/runtime/profiling"
         "github.com/luci/luci-go/logdog/client/annotee"
         "github.com/luci/luci-go/logdog/client/annotee/executor"
         "github.com/luci/luci-go/logdog/client/bootstrapResult"
         "github.com/luci/luci-go/logdog/client/butlerlib/bootstrap"
         "github.com/luci/luci-go/logdog/client/butlerlib/streamclient"
         "github.com/luci/luci-go/logdog/client/butlerlib/streamproto"
         "github.com/luci/luci-go/logdog/common/types"
         "golang.org/x/net/context"
 )
 
@@ skipping 28 matching lines @@
         butlerStreamServer string
         tee                bool
         printSummary       bool
         testingDir         string
         annotationInterval clockflag.Duration
         project            config.ProjectName
         nameBase           streamproto.StreamNameFlag
         prefix             streamproto.StreamNameFlag
         logdogHost         string
 
+        prof profiling.Profiler
+
         bootstrap *bootstrap.Bootstrap
 }
 
 func (a *application) addToFlagSet(fs *flag.FlagSet) {
         fs.Var(&a.annotate, "annotate",
                 "Annotation handling mode. Options are: "+annotationFlagEnum.Choices())
         fs.StringVar(&a.resultPath, "result-path", "",
                 "If supplied, a JSON file describing the bootstrap result will be written here if the bootstrapped process "+
                         "is successfully executed.")
         fs.StringVar(&a.jsonArgsPath, "json-args-path", "",
@@ skipping 74 matching lines @@
 
         // Determine bootstrapped process arguments.
         var err error
         a.bootstrap, err = bootstrap.Get()
         if err != nil {
                 log.WithError(err).Warningf(a, "Could not get LogDog Butler bootstrap information.")
         }
 
         fs := &flag.FlagSet{}
         logFlags.AddFlags(fs)
+        a.prof.AddFlags(fs)
         a.addToFlagSet(fs)
         if err := fs.Parse(args); err != nil {
                 log.WithError(err).Errorf(a, "Failed to parse flags.")
                 return configErrorReturnCode
         }
         a.Context = logFlags.Set(a.Context)
 
         client, err := a.getStreamClient()
         if err != nil {
                 log.WithError(err).Errorf(a, "Failed to get stream client instance.")
@@ skipping 37 matching lines @@
                 log.Errorf(a, "No command-line arguments were supplied.")
                 return configErrorReturnCode
         }
 
         // Translate "<=0" flag option to Processor's "0", indicating that every
         // update should be sent.
         if a.annotationInterval < 0 {
                 a.annotationInterval = 0
         }
 
+        // Start our profiling service. This will be a no-op if the profiler is not
+        // configured.
+        a.prof.Logger = log.Get(a)
+        if err := a.prof.Start(); err != nil {
+                log.WithError(err).Errorf(a, "Failed to start profiler.")
+                return runtimeErrorReturnCode
+        }
+
         // Initialize our link generator, if we can.
         e := executor.Executor{
                 Options: annotee.Options{
                         Base:                   types.StreamName(a.nameBase),
                         Client:                 client,
                         MetadataUpdateInterval: time.Duration(a.annotationInterval),
                         CloseSteps:             true,
                 },
 
                 Annotate: executor.AnnotationMode(a.annotate),
@@ skipping 42 matching lines @@
         }
         if err := a.maybeWriteResult(&br); err != nil {
                 log.WithError(err).Warningf(a, "Failed to write bootstrap result.")
         }
         return e.ReturnCode()
 }
 
 func main() {
         os.Exit(mainImpl(os.Args[1:]))
 }