Move --eventlog-endpoint out of isolateFlags.

client/cmd/isolate/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 (
         "errors"
         "fmt"
         "log"
@@ skipping 15 matching lines @@
 
 func cmdArchive(defaultAuthOpts auth.Options) *subcommands.Command {
         return &subcommands.Command{
                 UsageLine: "archive <options>",
                 ShortDesc: "creates a .isolated file and uploads the tree to an isolate server.",
                 LongDesc:  "All the files listed in the .isolated file are put in the isolate server cache",
                 CommandRun: func() subcommands.CommandRun {
                         c := archiveRun{}
                         c.commonServerFlags.Init(defaultAuthOpts)
                         c.isolateFlags.Init(&c.Flags)
+                        c.loggingFlags.Init(&c.Flags)
                         return &c
                 },
         }
 }
 
 type archiveRun struct {
         commonServerFlags
         isolateFlags
+        loggingFlags loggingFlags
 }
 
 func (c *archiveRun) Parse(a subcommands.Application, args []string) error {
         if err := c.commonServerFlags.Parse(); err != nil {
                 return err
         }
         cwd, err := os.Getwd()
         if err != nil {
                 return err
         }
@@ skipping 42 matching lines @@
 
         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())),
         }
         if item.Error() != nil {
                 archiveDetails.IsolateHash = []string{string(item.Digest())}
         }
-        eventlogger := NewLogger(ctx, c.isolateFlags.EventlogEndpoint)
+        eventlogger := NewLogger(ctx, c.loggingFlags.EventlogEndpoint)
         op := logpb.IsolateClientEvent_LEGACY_ARCHIVE.Enum()
         if err := eventlogger.logStats(ctx, op, start, end, archiveDetails); err != nil {
                 log.Printf("Failed to log to eventlog: %v", err)
         }
         return err
 }
 
 func (c *archiveRun) Run(a subcommands.Application, args []string, _ subcommands.Env) int {
         if err := c.Parse(a, args); err != nil {
                 fmt.Fprintf(a.GetErr(), "%s: %s\n", a.GetName(), err)
                 return 1
         }
         cl, err := c.defaultFlags.StartTracing()
         if err != nil {
                 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
 }