Move --eventlog-endpoint out of isolateFlags.

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 32 matching lines @@
 
 func cmdExpArchive(defaultAuthOpts auth.Options) *subcommands.Command {
         return &subcommands.Command{
                 UsageLine: "exparchive <options>",
                 ShortDesc: "EXPERIMENTAL parses a .isolate file to create a .isolated file, and uploads it and all referenced files to an isolate server",
                 LongDesc:  "All the files listed in the .isolated file are put in the isolate server cache. Small files are combined together in a tar archive before uploading.",
                 CommandRun: func() subcommands.CommandRun {
                         c := &expArchiveRun{}
                         c.commonServerFlags.Init(defaultAuthOpts)
                         c.isolateFlags.Init(&c.Flags)
+                        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
                 },
         }
 }
 
 // expArchiveRun contains the logic for the experimental archive subcommand.
 // It implements subcommand.CommandRun
 type expArchiveRun struct {
         commonServerFlags // Provides the GetFlags method.
         isolateFlags      isolateFlags
+        loggingFlags      loggingFlags
         dumpJSON          string
 }
 
 // Item represents a file or symlink referenced by an isolate file.
 type Item struct {
         Path    string
         RelPath string
         Size    int64
         Mode    os.FileMode
 
@@ skipping 204 matching lines @@
 
         end := time.Now()
 
         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)},
         }
-        eventlogger := NewLogger(ctx, c.isolateFlags.EventlogEndpoint)
+        eventlogger := NewLogger(ctx, c.loggingFlags.EventlogEndpoint)
         op := logpb.IsolateClientEvent_ARCHIVE.Enum()
         if err := eventlogger.logStats(ctx, op, start, end, archiveDetails); err != nil {
                 log.Printf("Failed to log to eventlog: %v", err)
         }
 
         return nil
 }
 
 func (c *expArchiveRun) parseFlags(args []string) error {
         if len(args) != 0 {
@@ 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)
 }