Log uses of isolate archive and exparchive when 'chromium' build tag is set.

client/cmd/isolate/isolate_event_logger.go

 // Copyright 2017 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 (
         "os"
         "time"
 
         "golang.org/x/net/context"
 
         "github.com/golang/protobuf/proto"
         "github.com/luci/luci-go/common/eventlog"
         logpb "github.com/luci/luci-go/common/eventlog/proto"
+        "github.com/luci/luci-go/common/logging"
 )
 
+// eventlogEndpoint returns a destination URL for eventlogs, based on the contents of
+// the endpointFlag.
+func eventlogEndpoint(ctx context.Context, endpointFlag string) string {
+        switch endpointFlag {
+        case "auto":
+                if autoEventlog() {
+                        msg := "Automatically logging usage statistics to %s. If this is not desired, then set --eventlog-endpoint=none"
+                        logging.Infof(ctx, msg, eventlog.ProdEndpoint)
+                        return eventlog.ProdEndpoint
+                }
+                return ""
+        case "test":
+                return eventlog.TestEndpoint
+        case "prod":
+                return eventlog.ProdEndpoint
+        case "none":
+                return ""
+        default:
+                return endpointFlag
+        }
+}
+
 type syncLogger interface {
         LogSync(ctx context.Context, events ...*eventlog.ChromeInfraLogEvent) error
         NewLogEvent(ctx context.Context, eventTime eventlog.TypedTime) *eventlog.ChromeInfraLogEvent
 }
 
 // An IsolateEventLogger logs eventlogs which contain stats about the data uploaded to the isolate server.
 type IsolateEventLogger struct {
         client syncLogger
 
         // getEnvironmentValue looks up the value of an environment variable.
         // Set this to override the default implementation for testing.
         getEnvironmentValue func(key string) *string
 }
 
 // NewLogger returns an IsolateEventLogger which logs to the specified endpoint.
+// endpoint is the URL to which logs will be sent.
 func NewLogger(ctx context.Context, endpoint string) *IsolateEventLogger {
         l := &IsolateEventLogger{}
-        if host := eventlogEndpoint(endpoint); host != "" {
-                l.client = eventlog.NewClient(ctx, host)
+        if endpoint != "" {
+                l.client = eventlog.NewClient(ctx, endpoint)
         }
         return l
 }
 
 // logStats synchronously logs an eventlog which describes an isolate run.
 func (l *IsolateEventLogger) logStats(ctx context.Context, op *logpb.IsolateClientEvent_Operation, start, end time.Time, archiveDetails *logpb.IsolateClientEvent_ArchiveDetails) error {
         if l.client == nil {
                 return nil
         }
         bi := l.getBuildbotInfo()
         event := l.client.NewLogEvent(ctx, eventlog.Point())
         event.InfraEvent.IsolateClientEvent = &logpb.IsolateClientEvent{
                 Binary: &logpb.Binary{
                         Name:          proto.String("isolate"),
                         VersionNumber: proto.String(version),
                 },
                 Operation:      op,
                 ArchiveDetails: archiveDetails,
                 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 l.client.LogSync(ctx, event)
 }
 
-func eventlogEndpoint(endpointFlag string) string {
-        switch endpointFlag {
-        case "test":
-                return eventlog.TestEndpoint
-        case "prod":
-                return eventlog.ProdEndpoint
-        default:
-                return endpointFlag
-        }
-}
-
 // 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 (l *IsolateEventLogger) getBuildbotInfo() *buildbotInfo {
         return &buildbotInfo{
                 master:  l.getEnvValue("BUILDBOT_MASTERNAME"),
                 builder: l.getEnvValue("BUILDBOT_BUILDERNAME"),
                 buildID: l.getEnvValue("BUILDBOT_BUILDNUMBER"),
                 slave:   l.getEnvValue("BUILDBOT_SLAVENAME"),
         }
 }
 
 func (l *IsolateEventLogger) getEnvValue(key string) *string {
         if l.getEnvironmentValue != nil {
                 return l.getEnvironmentValue(key)
         }
         if val, ok := os.LookupEnv(key); ok {
                 return &val
         }
         return nil
 }