LogDog: Update to archival V2.

server/internal/logdog/service/service.go

 // Copyright 2016 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 service
 
 import (
         "errors"
         "flag"
         "net/http"
@@ skipping 38 matching lines @@
         shutdownFunc atomic.Value
 
         loggingFlags log.Config
         authFlags    authcli.Flags
         configFlags  config.Flags
 
         coordinatorHost           string
         coordinatorInsecure       bool
         storageCredentialJSONPath string
         cpuProfilePath            string
+        heapProfilePath           string
 
         coord  logdog.ServicesClient
         config *config.Manager
 }
 
 // Run performs service-wide initialization and invokes the specified run
 // function.
 func (s *Service) Run(c context.Context, f func(context.Context) error) {
         c = gologger.Use(c)
 
@@ skipping 23 matching lines @@
                                 "path":       p,
                         }.Errorf(c, "Failed to create CPU profile output file.")
                         return err
                 }
                 defer fd.Close()
 
                 pprof.StartCPUProfile(fd)
                 defer pprof.StopCPUProfile()
         }
 
+        if p := s.heapProfilePath; p != "" {
+                defer func() {
+                        fd, err := os.Create(p)
+                        if err != nil {
+                                log.Fields{
+                                        log.ErrorKey: err,
+                                        "path":       p,
+                                }.Warningf(c, "Failed to create heap profile output file.")
+                                return
+                        }
+                        defer fd.Close()
+
+                        if err := pprof.WriteHeapProfile(fd); err != nil {
+                                log.Fields{
+                                        log.ErrorKey: err,
+                                        "path":       p,
+                                }.Warningf(c, "Failed to write heap profile.")
+                        }
+                }()
+        }
+
         // Configure our signal handler. It will listen for terminating signals and
         // issue a shutdown signal if one is received.
         signalC := make(chan os.Signal)
         go func() {
                 hasShutdownAlready := false
                 for sig := range signalC {
                         if !hasShutdownAlready {
                                 hasShutdownAlready = true
 
                                 log.Warningf(log.SetField(c, "signal", sig), "Received close signal. Send again to terminate immediately.")
@@ skipping 42 matching lines @@
         s.configFlags.AddToFlagSet(fs)
 
         fs.StringVar(&s.coordinatorHost, "coordinator", "",
                 "The Coordinator service's [host][:port].")
         fs.BoolVar(&s.coordinatorInsecure, "coordinator-insecure", false,
                 "Connect to Coordinator over HTTP (instead of HTTPS).")
         fs.StringVar(&s.storageCredentialJSONPath, "storage-credential-json-path", "",
                 "If supplied, the path of a JSON credential file to load and use for storage operations.")
         fs.StringVar(&s.cpuProfilePath, "cpu-profile-path", "",
                 "If supplied, enable CPU profiling and write the profile here.")
+        fs.StringVar(&s.heapProfilePath, "heap-profile-path", "",
+                "If supplied, enable CPU profiling and write the profile here.")
 }
 
 func (s *Service) initCoordinatorClient(c context.Context) (logdog.ServicesClient, error) {
         if s.coordinatorHost == "" {
                 log.Errorf(c, "Missing Coordinator URL (-coordinator).")
                 return nil, ErrInvalidConfig
         }
 
         httpClient, err := s.AuthenticatedClient(func(o *auth.Options) {
                 o.Scopes = CoordinatorScopes
@@ skipping 157 matching lines @@
 //
 // An optional permutation functon can be provided to modify those Options
 // before the Authenticator is created.
 func (s *Service) AuthenticatedClient(f func(o *auth.Options)) (*http.Client, error) {
         a, err := s.Authenticator(f)
         if err != nil {
                 return nil, err
         }
         return a.Client()
 }