Enable AppEngine profiling endpoints.

common/runtime/profiling/profiler.go

 // Copyright 2016 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 profiling
 
 import (
         "flag"
         "fmt"
         "net"
         "net/http"
         httpProf "net/http/pprof"

[Vadim Sh., 2016/12/18 22:44:37]

This import registers routes in default net/http router (in init()). Same as
used by GAE app. This can expose profiling info if user don't ever call
'InstallHandlers', or uses a router with some different suffix (not "/").

I think we should just follow standard lib: if an app wants profiling, it does
1) "import _ "net/http/pprof"
2) adds "/debug/pprof" as 'require: admin' to app.yaml

         "os"
         "path/filepath"
         "runtime"
         "runtime/pprof"
         "sync/atomic"
 
-        "github.com/julienschmidt/httprouter"
+        "github.com/luci/luci-go/server/router"
+
         "github.com/luci/luci-go/common/clock"
         "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/logging"
 )
 
 // Profiler helps setup and manage profiling
 type Profiler struct {
         // BindHTTP, if not empty, is the HTTP address to bind to.
         //
         // Can also be configured with "-profile-bind-http" flag.
@@ skipping 34 matching lines @@
         // If we have an output directory, start our CPU profiling.
         if p.BindHTTP != "" {
                 if err := p.startHTTP(); err != nil {
                         return errors.Annotate(err).Reason("failed to start HTTP server").Err()
                 }
         }
         return nil
 }
 
 func (p *Profiler) startHTTP() error {
-        // Register paths: https://golang.org/src/net/http/pprof/pprof.go
-        router := httprouter.New()
-        router.HandlerFunc("GET", "/debug/pprof/", httpProf.Index)
-        router.HandlerFunc("GET", "/debug/pprof/cmdline", httpProf.Cmdline)
-        router.HandlerFunc("GET", "/debug/pprof/profile", httpProf.Profile)
-        router.HandlerFunc("GET", "/debug/pprof/symbol", httpProf.Symbol)
-        router.HandlerFunc("GET", "/debug/pprof/trace", httpProf.Trace)
-        for _, p := range pprof.Profiles() {
-                name := p.Name()
-                router.Handler("GET", fmt.Sprintf("/debug/pprof/%s", name), httpProf.Handler(name))
-        }
+        r := router.New()
+        InstallHandlers(r, router.MiddlewareChain{})
 
         // Bind to our profiling port.
         l, err := net.Listen("tcp4", p.BindHTTP)
         if err != nil {
                 return errors.Annotate(err).Reason("failed to bind to TCP4 address: %(addr)q").
                         D("addr", p.BindHTTP).Err()
         }
 
         server := http.Server{
-                Handler: http.HandlerFunc(router.ServeHTTP),
+                Handler: http.HandlerFunc(r.ServeHTTP),
         }
         go func() {
                 if err := server.Serve(l); err != nil {
                         p.getLogger().Errorf("Error serving profile HTTP: %s", err)
                 }
         }()
         return nil
 }
 
 // Stop stops the Profiler's operations.
@@ skipping 46 matching lines @@
         counter := atomic.AddUint32(&p.pathCounter, 1) - 1
         return filepath.Join(p.Dir, fmt.Sprintf("%s_%d_%d.prof", base, now.Unix(), counter))
 }
 
 func (p *Profiler) getLogger() logging.Logger {
         if p.Logger != nil {
                 return p.Logger
         }
         return logging.Null
 }
+
+// InstallHandlers installs standard profiler paths into the supplied Router.
+//
+// See https://golang.org/src/net/http/pprof/pprof.go
+func InstallHandlers(r *router.Router, base router.MiddlewareChain) {
+        r.GET("/debug/pprof/", base, wrapHandlerFunc(httpProf.Index))
+        r.GET("/debug/pprof/cmdline", base, wrapHandlerFunc(httpProf.Cmdline))
+        r.GET("/debug/pprof/profile", base, wrapHandlerFunc(httpProf.Profile))
+        r.GET("/debug/pprof/symbol", base, wrapHandlerFunc(httpProf.Symbol))
+        r.GET("/debug/pprof/trace", base, wrapHandlerFunc(httpProf.Trace))
+        for _, p := range pprof.Profiles() {
+                name := p.Name()
+                r.GET(fmt.Sprintf("/debug/pprof/%s", name), base, wrapHandler(httpProf.Handler(name)))
+        }
+}
+
+func wrapHandlerFunc(h http.HandlerFunc) router.Handler {
+        return func(c *router.Context) {
+                h(c.Writer, c.Request)
+        }
+}
+
+func wrapHandler(h http.Handler) router.Handler {
+        return func(c *router.Context) {
+                h.ServeHTTP(c.Writer, c.Request)
+        }
+}