Update generated proto code for eventlogging

client/cmd/isolate/exp_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"
@@ skipping 83 matching lines @@
         ctx, cancel := context.WithCancel(context.Background())
         defer cancel()
 
         // Create the isolated client which connects to the isolate server.
         authCl, err := c.createAuthClient()
         if err != nil {
                 return err
         }
         client := isolatedclient.New(nil, authCl, c.isolatedFlags.ServerURL, c.isolatedFlags.Namespace, nil, nil)
 
-        // Set up a checker an uploader. We limit the uploader to one concurrent
+        // Set up a checker and uploader. We limit the uploader to one concurrent
         // upload, since the uploads are all coming from disk (with the exception of
         // the isolated JSON itself) and we only want a single goroutine reading from
         // disk at once.
         checker := NewChecker(ctx, client)
         uploader := NewUploader(ctx, client, 1)
 
         // Walk each of the deps, partioning the results into symlinks and files categorised by size.
         var links, archiveFiles, indivFiles []*Item
         var archiveSize, indivSize int64 // Cumulative size of archived/individual files.
         for _, dep := range deps {
@@ skipping 169 matching lines @@
                 logger := eventlog.NewClient(ctx, endpoint)
 
                 // TODO(mcgreevy): fill out more stats in archiveDetails.
                 archiveDetails := &logpb.IsolateClientEvent_ArchiveDetails{
                         HitCount:    proto.Int64(int64(checker.Hit.Count)),
                         MissCount:   proto.Int64(int64(checker.Miss.Count)),
                         HitBytes:    &checker.Hit.Bytes,
                         MissBytes:   &checker.Miss.Bytes,
                         IsolateHash: []string{string(isolItem.Digest)},
                 }
-                if err := logStats(ctx, logger, start, end, archiveDetails); err != nil {
+                if err := logStats(ctx, logger, start, end, archiveDetails, getBuildbotInfo()); err != nil {
                         log.Printf("Failed to log to eventlog: %v", err)
                 }
         }
 
         return nil
 }
 
 func (c *expArchiveRun) parseFlags(args []string) error {
         if len(args) != 0 {
                 return errors.New("position arguments not expected")
@@ skipping 30 matching lines @@
 
 func hashFile(path string) (isolated.HexDigest, error) {
         f, err := os.Open(path)
         if err != nil {
                 return "", err
         }
         defer f.Close()
         return isolated.Hash(f)
 }
 
-func logStats(ctx context.Context, logger *eventlog.Client, start, end time.Time, archiveDetails *logpb.IsolateClientEvent_ArchiveDetails) error {
+// buildbotInfo contains information about the build in which this command was run.
+type buildbotInfo struct {
+        // Variables which are not present in the environment are nil.
+        master, builder, buildID, slave *string
+}
+
+// getBuildbotInfo poulates a buildbotInfo with information from the environment.
+func getBuildbotInfo() *buildbotInfo {
+        getEnvValue := func(key string) *string {
+                if val, ok := os.LookupEnv(key); ok {
+                        return &val
+                }
+                return nil
+        }
+
+        return &buildbotInfo{
+                master:  getEnvValue("BUILDBOT_MASTERNAME"),
+                builder: getEnvValue("BUILDBOT_BUILDERNAME"),
+                buildID: getEnvValue("BUILDBOT_BUILDNUMBER"),
+                slave:   getEnvValue("BUILDBOT_SLAVENAME"),
+        }
+}
+
+func logStats(ctx context.Context, logger *eventlog.Client, start, end time.Time, archiveDetails *logpb.IsolateClientEvent_ArchiveDetails, bi *buildbotInfo) error {
         event := logger.NewLogEvent(ctx, eventlog.Point())
         event.InfraEvent.IsolateClientEvent = &logpb.IsolateClientEvent{
                 Binary: &logpb.Binary{
                         Name:          proto.String("isolate"),
                         VersionNumber: proto.String(version),
                 },
                 Operation:      logpb.IsolateClientEvent_ARCHIVE.Enum(),
                 ArchiveDetails: archiveDetails,
-                // TODO(mcgreevy): fill out Master, Builder, BuildId, Slave.
-                StartTsUsec: proto.Int64(int64(start.UnixNano() / 1e3)),
-                EndTsUsec:   proto.Int64(int64(end.UnixNano() / 1e3)),
+                Master:         bi.master,
+                Builder:        bi.builder,
+                BuildId:        bi.buildID,
+                Slave:          bi.slave,
+                StartTsUsec:    proto.Int64(int64(start.UnixNano() / 1e3)),
+                EndTsUsec:      proto.Int64(int64(end.UnixNano() / 1e3)),
         }
         return logger.LogSync(ctx, event)
 }
 
 func eventlogEndpoint(endpointFlag string) string {
         switch endpointFlag {
         case "test":
                 return eventlog.TestEndpoint
         case "prod":
                 return eventlog.ProdEndpoint
         default:
                 return endpointFlag
         }
 }