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"
 )
 
+// When --eventlog-endpoint=auto, we decide to send eventlogs based on whether --isolate-server matches prodIsolateServer

[M-A Ruel, 2017/06/08 14:06:05]

I don't understand why we don't want to log everywhere? Also there's many more
"prod" instances and I'd prefer not have to hardcode them here.

[mcgreevy, 2017/06/08 23:19:01]

The reason is that luci-go is an open source project, and I don't want to log
usages of it that are unrelated to the chromium project. Here's another idea,
though: rather than checking which isolateserver is being used, I could switch
logging on via a build tag, and enable that build tag when building the isolate
binary that we upload to GCS. That way the binary that we build for our own
purposes will automatically log, whereas when it's built by anyone else, it
wont.  WDYT?

+const prodIsolateServer = "https://isolateserver.appspot.com"
+
+// eventlogEndpoint returns a destination URL for eventlogs, based on the contents of
+// the endpointFlag and isolateServerFlag.
+func eventlogEndpoint(ctx context.Context, endpointFlag string, isolateServerFlag string) string {
+        switch endpointFlag {
+        case "auto":
+                if isolateServerFlag == prodIsolateServer {
+                        // If we are uploading to the prod server, we log this activity.
+                        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
 }