func TestLogger(t *testing.T) {
Convey("logger", t, func() {
c := Use(logging.SetLevel(context.Background(), logging.Debug))
l := logging.Get(c)
So(l, ShouldNotBeNil)
l.Debugf("test %s", logging.Debug)
l.Infof("test %s", logging.Info)
l.Warningf("test %s", logging.Warning)
l.Errorf("test %s", logging.Error)
l.Errorf("test WAT: %s", logging.Level(9001))
ml := l.(*MemLogger)
mld := ml.data
So(len(*mld), ShouldEqual, 5)
So((*mld)[0], ShouldResemble, LogEntry{logging.Debug, "test debug", nil})
So((*mld)[1], ShouldResemble, LogEntry{logging.Info, "test info", nil})
So((*mld)[2], ShouldResemble, LogEntry{logging.Warning, "test warning", nil})
So((*mld)[3], ShouldResemble, LogEntry{logging.Error, "test error", nil})
So((*mld)[4], ShouldResemble, LogEntry{logging.Error, "test WAT: unknown", nil})
})
Convey("logger context", t, func() {
c := Use(context.Background())
l := logging.Get(c)
So(l, ShouldNotBeNil)
ml := l.(*MemLogger)
l.Infof("totally works: %s", "yes")
So(len(*ml.data), ShouldEqual, 1)
So((*ml.data)[0], ShouldResemble, LogEntry{logging.Info, "totally works: yes", nil})
})
Convey("field data", t, func() {
c := Use(context.Background())
data := map[string]interface{}{
"trombone": 50,
"cat": "amazing",
}
c = logging.SetFields(c, logging.NewFields(data))
l := logging.Get(c)
ml := l.(*MemLogger)
l.Infof("Some unsuspecting log")
So((*ml.data)[0].Data["trombone"], ShouldEqual, 50)
So((*ml.data)[0].Data["cat"], ShouldEqual, "amazing")
})
}
// Run will run f every cyle (at least once), and fail if maxErrs are returned by
// f in a row. It returns Results indiciating success, number of overruns and
// errors. Use context.WithCancel/Timeout/Deadline to limit the overall run time.
func Run(ctx context.Context, f Runner, cycle time.Duration, maxErrs int, c clock.Clock) (ret *Results) {
// TODO: ts_mon stuff.
ret = &Results{Success: true}
tmr := c.NewTimer()
defer tmr.Stop()
nextCycle := cycle
consecErrs := 0
log := logging.Get(ctx)
run := func() {
t0 := c.Now()
// TODO(seanmccullough) Optionally cancel overruns via context.WithTimeout.
err := f(ctx)
dur := c.Now().Sub(t0)
if dur > cycle {
log.Errorf("Task overran by %v (%v - %v)", (dur - cycle), dur, cycle)
ret.Overruns++
}
if err != nil {
log.Errorf("Got an error: %v", err)
ret.Errs++
if consecErrs++; consecErrs >= maxErrs {
ret.Success = false
return
}
} else {
consecErrs = 0
}
nextCycle = cycle - dur
if tmr.Reset(nextCycle) {
log.Errorf("Timer was still active")
}
}
// Run f at least once.
run()
// Keep running f until ctx is done.
for {
select {
case <-ctx.Done():
tmr.Stop()
return ret
case <-tmr.GetC():
run()
}
}
}
func (c *config) createAuthenticatedClient(ctx context.Context) (*http.Client, error) {
scopes := []string{}
scopes = append(scopes, cloudLoggingScopes...)
scopes = append(scopes, pubsubScopes...)
// Get our authenticated client.
options := auth.Options{
Scopes: scopes,
ServiceAccountJSONPath: c.serviceAccountJSONPath,
Logger: log.Get(ctx),
}
authenticator := auth.NewAuthenticator(options)
mode := auth.SilentLogin
if c.authInteractive {
mode = auth.InteractiveLogin
}
return auth.AuthenticatedClient(mode, authenticator)
}
func TestAuthenticator(t *testing.T) {
Convey("Given mocked secrets dir", t, func() {
tempDir := mockSecretsDir()
Convey("Check NewAuthenticator defaults", func() {
clientID, clientSecret := DefaultClient()
ctx := context.Background()
a := NewAuthenticator(Options{Context: ctx}).(*authenticatorImpl)
So(a.opts, ShouldResemble, &Options{
Method: AutoSelectMethod,
Scopes: []string{OAuthScopeEmail},
ClientID: clientID,
ClientSecret: clientSecret,
ServiceAccountJSONPath: filepath.Join(tempDir, "service_account.json"),
GCEAccountName: "default",
Context: ctx,
Logger: logging.Get(ctx),
})
})
})
}
func TestCloudLoggingConfig(t *testing.T) {
Convey(`A test logging config, using a test HTTP client/server`, t, func() {
ctx := context.Background()
config := &loggerConfig{
projectName: "test-project",
resourceType: "test-resource",
logsID: "test-logs-id",
}
client := &http.Client{}
Convey(`Requires a project name.`, func() {
config.projectName = ""
_, _, err := config.use(ctx, client)
So(err, ShouldNotBeNil)
})
Convey(`Requires a resource type.`, func() {
config.resourceType = ""
_, _, err := config.use(ctx, client)
So(err, ShouldNotBeNil)
})
Convey(`Requires a logs ID.`, func() {
config.logsID = ""
_, _, err := config.use(ctx, client)
So(err, ShouldNotBeNil)
})
Convey(`Installs a bound cloud logger into a context.`, func() {
ctx, closeFunc, err := config.use(ctx, client)
So(err, ShouldBeNil)
defer closeFunc()
So(log.Get(ctx), ShouldHaveSameTypeAs, &boundCloudLogger{})
})
})
}
func (c *endpointConfig) createService(ctx context.Context) (endpointService, error) {
if c.url == "" {
return nil, errors.New("endpoint: you must supply a monitoring endpoint")
}
authenticator := auth.NewAuthenticator(
auth.Options{
Method: auth.ServiceAccountMethod,
Scopes: endpointScopes,
ServiceAccountJSONPath: c.serviceAccountJSONPath,
Logger: log.Get(ctx),
})
client, err := auth.AuthenticatedClient(auth.SilentLogin, authenticator)
if err != nil {
log.Errorf(log.SetError(ctx, err), "Failed to configure endpoint client.")
return nil, errors.New("endpoint: failed to configure endpoint client")
}
return &endpointServiceImpl{
endpointConfig: *c,
client: client,
}, nil
}
// NewAuthenticator returns a new instance of Authenticator given its options.
func NewAuthenticator(opts Options) Authenticator {
// Add default scope, sort scopes.
if len(opts.Scopes) == 0 {
opts.Scopes = []string{OAuthScopeEmail}
}
tmp := make([]string, len(opts.Scopes))
copy(tmp, opts.Scopes)
sort.Strings(tmp)
opts.Scopes = tmp
// Fill in blanks with default values.
if opts.ClientID == "" || opts.ClientSecret == "" {
opts.ClientID, opts.ClientSecret = DefaultClient()
}
if opts.ServiceAccountJSONPath == "" {
opts.ServiceAccountJSONPath = filepath.Join(SecretsDir(), "service_account.json")
}
if opts.GCEAccountName == "" {
opts.GCEAccountName = "default"
}
if opts.Context == nil {
opts.Context = context.Background()
}
if opts.Logger == nil {
opts.Logger = logging.Get(opts.Context)
}
// See ensureInitialized for the rest of the initialization.
auth := &authenticatorImpl{opts: &opts, log: opts.Logger}
auth.transport = &authTransport{
parent: auth,
base: internal.TransportFromContext(opts.Context),
log: opts.Logger,
}
return auth
}