Add eventlogging to batcharchive.

client/cmd/isolate/batch_archive.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"
         "fmt"
         "io"
+        "log"
         "os"
         "path/filepath"
         "strings"
         "sync"
         "time"
 
+        "github.com/golang/protobuf/proto"
         "github.com/maruel/subcommands"
 
         "github.com/luci/luci-go/client/archiver"
         "github.com/luci/luci-go/client/isolate"
         "github.com/luci/luci-go/common/auth"
         "github.com/luci/luci-go/common/data/text/units"
+        logpb "github.com/luci/luci-go/common/eventlog/proto"
         "github.com/luci/luci-go/common/isolated"
         "github.com/luci/luci-go/common/isolatedclient"
 )
 
 func cmdBatchArchive(defaultAuthOpts auth.Options) *subcommands.Command {
         return &subcommands.Command{
                 UsageLine: "batcharchive <options> file1 file2 ...",
                 ShortDesc: "archives multiple isolated trees at once.",
                 LongDesc: `Archives multiple isolated trees at once.
 
 Using single command instead of multiple sequential invocations allows to cut
 redundant work when isolated trees share common files (e.g. file hashes are
 checked only once, their presence on the server is checked only once, and
 so on).
 
 Takes a list of paths to *.isolated.gen.json files that describe what trees to
 isolate. Format of files is:
 {
   "version": 1,
   "dir": <absolute path to a directory all other paths are relative to>,
   "args": [list of command line arguments for single 'archive' command]
 }`,
                 CommandRun: func() subcommands.CommandRun {
                         c := batchArchiveRun{}
                         c.commonServerFlags.Init(defaultAuthOpts)
+                        c.loggingFlags.Init(&c.Flags)
                         c.Flags.StringVar(&c.dumpJSON, "dump-json", "",
                                 "Write isolated digests of archived trees to this file as JSON")
                         return &c
                 },
         }
 }
 
 type batchArchiveRun struct {
         commonServerFlags
-        dumpJSON string
+        loggingFlags loggingFlags
+        dumpJSON     string
 }
 
 func (c *batchArchiveRun) Parse(a subcommands.Application, args []string) error {
         if err := c.commonServerFlags.Parse(); err != nil {
                 return err
         }
         if len(args) == 0 {
                 return errors.New("at least one isolate file required")
         }
         return nil
@@ skipping 86 matching lines @@
                                 }
                         }
                 }(arg)
         }
         go func() {
                 wg.Wait()
                 close(items)
         }()
 
         data := map[string]isolated.HexDigest{}
+        var digests []string
         for item := range items {
                 item.WaitForHashed()
                 if item.Error() == nil {
-                        data[item.name] = item.Digest()
-                        fmt.Printf("%s%s  %s\n", prefix, item.Digest(), item.name)
+                        d := item.Digest()
+                        data[item.name] = d
+                        digests = append(digests, string(d))
+                        fmt.Printf("%s%s  %s\n", prefix, d, item.name)
                 } else {
                         fmt.Fprintf(os.Stderr, "%s%s  %s\n", prefix, item.name, item.Error())
                 }
         }
         err = arch.Close()
         duration := time.Since(start)
         // Only write the file once upload is confirmed.
         if err == nil && c.dumpJSON != "" {
                 err = writeJSONDigestFile(c.dumpJSON, data)
         }
+
+        stats := arch.Stats()
         if !c.defaultFlags.Quiet {
-                stats := arch.Stats()
                 fmt.Fprintf(os.Stderr, "Hits    : %5d (%s)\n", stats.TotalHits(), stats.TotalBytesHits())
                 fmt.Fprintf(os.Stderr, "Misses  : %5d (%s)\n", stats.TotalMisses(), stats.TotalBytesPushed())
                 fmt.Fprintf(os.Stderr, "Duration: %s\n", units.Round(duration, time.Millisecond))
         }
+
+        end := time.Now()
+        archiveDetails := &logpb.IsolateClientEvent_ArchiveDetails{
+                HitCount:    proto.Int64(int64(stats.TotalHits())),
+                MissCount:   proto.Int64(int64(stats.TotalMisses())),
+                HitBytes:    proto.Int64(int64(stats.TotalBytesHits())),
+                MissBytes:   proto.Int64(int64(stats.TotalBytesPushed())),
+                IsolateHash: digests,
+        }
+
+        eventlogger := NewLogger(ctx, c.loggingFlags.EventlogEndpoint)
+        op := logpb.IsolateClientEvent_BATCH_ARCHIVE.Enum()
+        if err := eventlogger.logStats(ctx, op, start, end, archiveDetails); err != nil {
+                log.Printf("Failed to log to eventlog: %v", err)
+        }
+
         return err
 }
 
 // processGenJSON validates a genJSON file and returns the contents.
 func processGenJSON(genJSONPath string) (*isolate.ArchiveOptions, error) {
         f, err := os.Open(genJSONPath)
         if err != nil {
                 return nil, fmt.Errorf("opening %s: %s", genJSONPath, err)
         }
         defer f.Close()
@@ skipping 77 matching lines @@
                 fmt.Fprintf(a.GetErr(), "%s: %s\n", a.GetName(), err)
                 return 1
         }
         defer cl.Close()
         if err := c.main(a, args); err != nil {
                 fmt.Fprintf(a.GetErr(), "%s: %s\n", a.GetName(), err)
                 return 1
         }
         return 0
 }