Milo flex raw log viewer endpoint

milo/appengine/common/middleware.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 common
 
 import (
         "net/http"
         "strings"
 
+        "cloud.google.com/go/compute/metadata"
+
         "golang.org/x/net/context"
 
+        "github.com/luci/gae/impl/cloud"
         "github.com/luci/gae/service/info"
         "github.com/luci/luci-go/appengine/gaeauth/server"
         "github.com/luci/luci-go/appengine/gaemiddleware"
         "github.com/luci/luci-go/common/clock"
+        "github.com/luci/luci-go/common/cloudlogging"
+        "github.com/luci/luci-go/common/logging/cloudlog"
         "github.com/luci/luci-go/server/analytics"
         "github.com/luci/luci-go/server/auth"
         "github.com/luci/luci-go/server/auth/identity"
         "github.com/luci/luci-go/server/router"
         "github.com/luci/luci-go/server/templates"
 )
 
+var authconfig *auth.Config
+
 // GetTemplateBundles is used to render HTML templates. It provides base args
 // passed to all templates.
 func GetTemplateBundle() *templates.Bundle {
         return &templates.Bundle{
                 Loader:          templates.FileSystemLoader("templates"),
                 DebugMode:       info.IsDevAppServer,
                 DefaultTemplate: "base",
                 DefaultArgs: func(c context.Context) (templates.Args, error) {
                         r := getRequest(c)
                         path := r.URL.Path
@@ skipping 23 matching lines @@
 
 // Base returns the basic LUCI appengine middlewares.
 func Base() router.MiddlewareChain {
         return gaemiddleware.BaseProd().Extend(
                 auth.Authenticate(server.CookieAuth),
                 withRequestMiddleware,
                 templates.WithTemplates(GetTemplateBundle()),
         )
 }
 
+// Flex returns the basic middleware for use on appengine flex.  Flex does not

[nodir, 2017/04/29 00:59:44]

s/Flex/FlexBase/

[hinoka, 2017/05/01 23:08:02]

Done.

+// allow the use of appengine APIs.
+func FlexBase() router.MiddlewareChain {
+        // Get the name of this project from the metadata server, since we're on GCE.
+        project, err := metadata.Get("project/project-id")
+        if err != nil {
+                panic(err)
+        }
+        // Use the cloud logger.
+        logger := func(c *router.Context, next router.Handler) {
+                logClient, err := cloudlogging.NewClient(
+                        cloudlogging.ClientOptions{
+                                ProjectID:    project,
+                                LogID:        "gae_app",
+                                ResourceType: "gae_app",
+                        },
+                        http.DefaultClient)

[nodir, 2017/04/29 00:59:44]

i doubt cloud logging API will accept anonymous requests

[hinoka, 2017/05/01 23:08:02]

Acknowledged.  This probably doesn't work, adding TODO, since all thats required
is to swap out the roundtripper.

+                if err != nil {
+                        panic(err)
+                }
+                cloudlog.Use(c.Context, cloudlog.Config{}, logClient)

[nodir, 2017/04/29 00:59:45]

this is noop because it misses c.Context = ...

possibly all stdout or stderr is automatically sent to cloud logging

[hinoka, 2017/05/01 23:08:02]

Oh you're right.. that explains a lot.

+                next(c)
+        }
+        // Installs the Info and Datastore services.
+        base := func(c *router.Context, next router.Handler) {
+                c.Context = cloud.UseFlex(c.Context)
+                next(c)
+        }
+        // Now chain it all together!
+        return router.NewMiddlewareChain(logger, base)

[nodir, 2017/04/29 00:59:44]

why logger comes before base? if you plan to log using cloudlogging, you may
need app service account which is probably accessibly only after base is
initialized

[hinoka, 2017/05/01 23:08:02]

Done.

+}
+
 // The context key, so that we can embed the http.Request object into
 // the context.
 var requestKey = "http.request"
 
 // WithRequest returns a context with the http.Request object
 // in it.
 func WithRequest(c context.Context, r *http.Request) context.Context {
         return context.WithValue(c, &requestKey, r)
 }
 
 // withRequestMiddleware is a middleware that installs a request into the context.
 // This is used for various things in the default template.
 func withRequestMiddleware(c *router.Context, next router.Handler) {
         c.Context = WithRequest(c.Context, c.Request)
         next(c)
 }
 
 func getRequest(c context.Context) *http.Request {
         if req, ok := c.Value(&requestKey).(*http.Request); ok {
                 return req
         }
         panic("No http.request found in context")
 }