// ServeHTTP responds to HTTP request to the handler.
func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
h.statMap.Add(statRequest, 1)
// FIXME(benbjohnson): Add pprof enabled flag.
if strings.HasPrefix(r.URL.Path, "/debug/pprof") {
switch r.URL.Path {
case "/debug/pprof/cmdline":
pprof.Cmdline(w, r)
case "/debug/pprof/profile":
pprof.Profile(w, r)
case "/debug/pprof/symbol":
pprof.Symbol(w, r)
default:
pprof.Index(w, r)
}
} else if strings.HasPrefix(r.URL.Path, "/debug/vars") {
serveExpvar(w, r)
} else {
method := r.Method
if method == "" {
method = "GET"
}
if mux, ok := h.methodMux[method]; ok {
mux.ServeHTTP(w, r)
}
}
}
// 根据 config.Pprof 决定是否包装调试地址
func (cfg *Config) buildPprof(h http.Handler) http.Handler {
if len(cfg.Pprof) > 0 {
logs.Debug("web:", "开启了调试功能，地址为：", cfg.Pprof)
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if !strings.HasPrefix(r.URL.Path, cfg.Pprof) {
h.ServeHTTP(w, r)
return
}
path := r.URL.Path[len(cfg.Pprof):]
switch path {
case "cmdline":
pprof.Cmdline(w, r)
case "profile":
pprof.Profile(w, r)
case "symbol":
pprof.Symbol(w, r)
case "trace":
pprof.Trace(w, r)
default:
pprof.Index(w, r)
}
})
}
return h
}
// Handler returns an http.HandlerFunc that returns pprof profiles
// and additional metrics.
// The handler must be accessible through the "/debug/_gom" route
// in order for gom to display the stats from the debugged program.
// See the godoc examples for usage.
func Handler() http.HandlerFunc {
// TODO(jbd): enable block profile.
return func(w http.ResponseWriter, r *http.Request) {
switch r.URL.Query().Get("view") {
case "profile":
name := r.URL.Query().Get("name")
if name == "profile" {
httppprof.Profile(w, r)
return
}
httppprof.Handler(name).ServeHTTP(w, r)
return
case "symbol":
httppprof.Symbol(w, r)
return
}
n := &stats{
Goroutine: pprof.Lookup("goroutine").Count(),
Thread: pprof.Lookup("threadcreate").Count(),
Block: pprof.Lookup("block").Count(),
Timestamp: time.Now().Unix(),
}
err := json.NewEncoder(w).Encode(n)
if err != nil {
w.WriteHeader(500)
fmt.Fprint(w, err)
}
}
}
func (s *httpServer) debugRouter(w http.ResponseWriter, req *http.Request) error {
switch req.URL.Path {
case "/debug":
util.NegotiateAPIResponseWrapper(w, req,
func() (interface{}, error) { return s.doDebug(req) })
case "/debug/pprof":
httpprof.Index(w, req)
case "/debug/pprof/cmdline":
httpprof.Cmdline(w, req)
case "/debug/pprof/symbol":
httpprof.Symbol(w, req)
case "/debug/pprof/heap":
httpprof.Handler("heap").ServeHTTP(w, req)
case "/debug/pprof/goroutine":
httpprof.Handler("goroutine").ServeHTTP(w, req)
case "/debug/pprof/profile":
httpprof.Profile(w, req)
case "/debug/pprof/block":
httpprof.Handler("block").ServeHTTP(w, req)
case "/debug/pprof/threadcreate":
httpprof.Handler("threadcreate").ServeHTTP(w, req)
default:
return errors.New(fmt.Sprintf("404 %s", req.URL.Path))
}
return nil
}
func (s *httpServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
switch req.URL.Path {
case "/registration":
s.registerHandler(w, req)
case "/ping":
s.pingHandler(w, req)
case "/info":
s.infoHandler(w, req)
case "/debug/pprof":
httpprof.Index(w, req)
case "/debug/pprof/cmdline":
httpprof.Cmdline(w, req)
case "/debug/pprof/symbol":
httpprof.Symbol(w, req)
case "/debug/pprof/heap":
httpprof.Handler("heap").ServeHTTP(w, req)
case "/debug/pprof/goroutine":
httpprof.Handler("goroutine").ServeHTTP(w, req)
case "/debug/pprof/profile":
httpprof.Profile(w, req)
case "/debug/pprof/block":
httpprof.Handler("block").ServeHTTP(w, req)
case "/debug/pprof/threadcreate":
httpprof.Handler("threadcreate").ServeHTTP(w, req)
default:
log.Printf("ERROR: 404 %s", req.URL.Path)
util.ApiResponse(w, 404, "NOT_FOUND", nil)
}
}
func symbolHandler(w http.ResponseWriter, r *http.Request, t auth.Token) error {
if !permission.Check(t, permission.PermDebug) {
return permission.ErrUnauthorized
}
pprof.Symbol(w, r)
return nil
}
func (a *App) maybeRegisterPProfHandlers() {
if enableProfiling, _ := a.Cfg.GetBool("gop", "enable_profiling_urls", false); enableProfiling && !a.configHandlersEnabled {
a.HandleFunc("/debug/pprof/cmdline", func(g *Req) error {
pprof.Cmdline(g.W, g.R)
return nil
})
a.HandleFunc("/debug/pprof/symbol", func(g *Req) error {
pprof.Symbol(g.W, g.R)
return nil
})
a.HandleFunc("/debug/pprof/profile", func(g *Req) error {
pprof.Profile(g.W, g.R)
return nil
})
a.HandleFunc("/debug/pprof/{profile_name}", func(g *Req) error {
vars := mux.Vars(g.R)
h := pprof.Handler(vars["profile_name"])
h.ServeHTTP(g.W, g.R)
return nil
})
a.configHandlersEnabled = true
}
}
func (hs *httpSrv) routerV01(w http.ResponseWriter, req *http.Request) {
switch req.URL.Path {
case "/ping":
hs.pingHandler(w, req)
case "/debug/pprof":
setPub(w)
httpprof.Index(w, req)
case "/debug/pprof/block":
hs.debugRuntime(w, req, "block")
case "/debug/pprof/goroutine":
hs.debugRuntime(w, req, "goroutine")
case "/debug/pprof/heap":
hs.debugRuntime(w, req, "heap")
case "/debug/pprof/threadcreate":
hs.debugRuntime(w, req, "threadcreate")
case "/debug/pprof/profile":
setPub(w)
httpprof.Profile(w, req)
case "/debug/pprof/cmdline":
setPub(w)
httpprof.Cmdline(w, req)
case "/debug/pprof/symbol":
setPub(w)
httpprof.Symbol(w, req)
default:
RespondV1(w, 404, "page not found")
}
}
// ServeHTTP responds to HTTP request to the handler.
func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
h.statMap.Add(statRequest, 1)
h.statMap.Add(statRequestsActive, 1)
start := time.Now()
// FIXME(benbjohnson): Add pprof enabled flag.
if strings.HasPrefix(r.URL.Path, "/debug/pprof") {
switch r.URL.Path {
case "/debug/pprof/cmdline":
pprof.Cmdline(w, r)
case "/debug/pprof/profile":
pprof.Profile(w, r)
case "/debug/pprof/symbol":
pprof.Symbol(w, r)
default:
pprof.Index(w, r)
}
} else if strings.HasPrefix(r.URL.Path, "/debug/vars") {
serveExpvar(w, r)
} else {
h.mux.ServeHTTP(w, r)
}
h.statMap.Add(statRequestsActive, -1)
h.statMap.Add(statRequestDuration, time.Since(start).Nanoseconds())
}
func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
//h.statMap.Add(statRequest, 1)
counter := metrics.GetOrRegisterCounter(statRequest, h.statMap)
counter.Inc(1)
meter := metrics.GetOrRegisterMeter(statRequestNew, h.statMap)
meter.Mark(1)
// FIXME(benbjohnson): Add pprof enabled flag.
if strings.HasPrefix(r.URL.Path, "/debug/pprof") {
switch r.URL.Path {
case "/debug/pprof/cmdline":
pprof.Cmdline(w, r)
case "/debug/pprof/profile":
pprof.Profile(w, r)
case "/debug/pprof/symbol":
pprof.Symbol(w, r)
default:
pprof.Index(w, r)
}
} else {
h.mux.ServeHTTP(w, r)
return
}
}
func (s *UnitedAdmin) ServeHTTP(w http.ResponseWriter, req *http.Request) {
if !utils.AllowMethod(w, req.Method, "HEAD", "GET", "POST", "PUT", "DELETE") {
return
}
if strings.HasPrefix(req.URL.Path, queuePrefixV1) {
key := req.URL.Path[len(queuePrefixV1):]
s.queueHandler(w, req, key)
return
} else if strings.HasPrefix(req.URL.Path, adminPrefixV1) {
key := req.URL.Path[len(adminPrefixV1):]
s.adminHandler(w, req, key)
return
} else if strings.HasPrefix(req.URL.Path, pprofPrefixCmd) {
httpprof.Cmdline(w, req)
return
} else if strings.HasPrefix(req.URL.Path, pprofPrefixProfile) {
httpprof.Profile(w, req)
return
} else if strings.HasPrefix(req.URL.Path, pprofPrefixSymbol) {
httpprof.Symbol(w, req)
return
} else if strings.HasPrefix(req.URL.Path, pprofPrefixIndex) {
httpprof.Index(w, req)
return
}
http.Error(w, "404 Not Found!", http.StatusNotFound)
return
}
func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
if strings.HasPrefix(r.URL.Path, "/debug/pprof") {
switch r.URL.Path {
case "/debug/pprof/cmdline":
pprof.Cmdline(w, r)
case "/debug/pprof/profile":
pprof.Profile(w, r)
case "/debug/pprof/symbol":
pprof.Symbol(w, r)
default:
pprof.Index(w, r)
}
return
}
switch r.URL.Path {
case "/":
h.serveRoot(w, r)
case "/top":
h.serveTop(w, r)
case "/top/stats":
h.serveTopStats(w, r)
case "/repositories":
h.serveRepositories(w, r)
case "/backup":
h.serveBackup(w, r)
case "/debug/vars":
h.serveExpvars(w, r)
default:
http.NotFound(w, r)
}
}
func setupHandlers(metricSink *metricsink.MetricSink, podLister *cache.StoreToPodLister) http.Handler {
runningInKubernetes := true
// Make API handler.
wsContainer := restful.NewContainer()
wsContainer.EnableContentEncoding(true)
wsContainer.Router(restful.CurlyRouter{})
a := v1.NewApi(runningInKubernetes, metricSink)
a.Register(wsContainer)
// Metrics API
m := metricsApi.NewApi(metricSink, podLister)
m.Register(wsContainer)
handlePprofEndpoint := func(req *restful.Request, resp *restful.Response) {
name := strings.TrimPrefix(req.Request.URL.Path, pprofBasePath)
switch name {
case "profile":
pprof.Profile(resp, req.Request)
case "symbol":
pprof.Symbol(resp, req.Request)
case "cmdline":
pprof.Cmdline(resp, req.Request)
default:
pprof.Index(resp, req.Request)
}
}
// Setup pporf handlers.
ws := new(restful.WebService).Path(pprofBasePath)
ws.Route(ws.GET("/{subpath:*}").To(metrics.InstrumentRouteFunc("pprof", handlePprofEndpoint))).Doc("pprof endpoint")
wsContainer.Add(ws)
return wsContainer
}
func handler() http.Handler {
info := struct {
Profiles []*pprof.Profile
Token string
}{
Profiles: pprof.Profiles(),
}
h := func(w http.ResponseWriter, r *http.Request) {
// get the last path, allowing this to be mounted under any prefix
split := strings.Split(r.URL.Path, "/")
name := split[len(split)-1]
switch name {
case "":
// Index page.
if err := indexTmpl.Execute(w, info); err != nil {
fmt.Fprintf(w, "something went wrong - %s", err)
return
}
case "cmdline":
nhpprof.Cmdline(w, r)
case "profile":
nhpprof.Profile(w, r)
case "trace":
nhpprof.Trace(w, r)
case "symbol":
nhpprof.Symbol(w, r)
default:
// Provides access to all profiles under runtime/pprof
nhpprof.Handler(name).ServeHTTP(w, r)
}
}
return http.HandlerFunc(h)
}
// ServeHTTP responds to HTTP request to the handler.
func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
atomic.AddInt64(&h.stats.Requests, 1)
atomic.AddInt64(&h.stats.ActiveRequests, 1)
defer atomic.AddInt64(&h.stats.ActiveRequests, -1)
start := time.Now()
// Add version header to all InfluxDB requests.
w.Header().Add("X-Influxdb-Version", h.Version)
// FIXME(benbjohnson): Add pprof enabled flag.
if strings.HasPrefix(r.URL.Path, "/debug/pprof") {
switch r.URL.Path {
case "/debug/pprof/cmdline":
pprof.Cmdline(w, r)
case "/debug/pprof/profile":
pprof.Profile(w, r)
case "/debug/pprof/symbol":
pprof.Symbol(w, r)
default:
pprof.Index(w, r)
}
} else if strings.HasPrefix(r.URL.Path, "/debug/vars") {
h.serveExpvar(w, r)
} else {
h.mux.ServeHTTP(w, r)
}
atomic.AddInt64(&h.stats.RequestDuration, time.Since(start).Nanoseconds())
}
func (s *httpServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
switch req.URL.Path {
case "/pub":
fallthrough
case "/put":
s.putHandler(w, req)
case "/mpub":
fallthrough
case "/mput":
s.mputHandler(w, req)
case "/stats":
s.statsHandler(w, req)
case "/ping":
s.pingHandler(w, req)
case "/info":
s.infoHandler(w, req)
case "/empty_topic":
s.emptyTopicHandler(w, req)
case "/delete_topic":
s.deleteTopicHandler(w, req)
case "/pause_topic":
s.pauseTopicHandler(w, req)
case "/unpause_topic":
s.pauseTopicHandler(w, req)
case "/empty_channel":
s.emptyChannelHandler(w, req)
case "/delete_channel":
s.deleteChannelHandler(w, req)
case "/pause_channel":
s.pauseChannelHandler(w, req)
case "/unpause_channel":
s.pauseChannelHandler(w, req)
case "/create_topic":
s.createTopicHandler(w, req)
case "/create_channel":
s.createChannelHandler(w, req)
case "/debug/pprof":
httpprof.Index(w, req)
case "/debug/pprof/cmdline":
httpprof.Cmdline(w, req)
case "/debug/pprof/symbol":
httpprof.Symbol(w, req)
case "/debug/pprof/heap":
httpprof.Handler("heap").ServeHTTP(w, req)
case "/debug/pprof/goroutine":
httpprof.Handler("goroutine").ServeHTTP(w, req)
case "/debug/pprof/profile":
httpprof.Profile(w, req)
case "/debug/pprof/block":
httpprof.Handler("block").ServeHTTP(w, req)
case "/debug/pprof/threadcreate":
httpprof.Handler("threadcreate").ServeHTTP(w, req)
default:
log.Printf("ERROR: 404 %s", req.URL.Path)
util.ApiResponse(w, 404, "NOT_FOUND", nil)
}
}
func handlePprof(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
switch p.ByName("pprof") {
case "/cmdline":
pprof.Cmdline(w, r)
case "/profile":
pprof.Profile(w, r)
case "/symbol":
pprof.Symbol(w, r)
default:
pprof.Index(w, r)
}
}
func (profileHandler) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
switch req.URL.Path {
case "/debug/pprof/cmdline":
pprof.Cmdline(rw, req)
case "/debug/pprof/profile":
pprof.Profile(rw, req)
case "/debug/pprof/symbol":
pprof.Symbol(rw, req)
default:
pprof.Index(rw, req)
}
}
// servePprof serves pprof information over HTTP.
func servePprof(w http.ResponseWriter, r *http.Request) {
switch r.URL.Path {
case "/debug/pprof/cmdline":
pprof.Cmdline(w, r)
case "/debug/pprof/profile":
pprof.Profile(w, r)
case "/debug/pprof/symbol":
pprof.Symbol(w, r)
default:
pprof.Index(w, r)
}
}
func (self *GLWeb) ServeHTTP(w http.ResponseWriter, r *http.Request) {
log.Infoln("Request ", r.Method, r.URL.Path)
w.Header().Add("Access-Control-Allow-Origin", "*")
if r.Method == "GET" && r.URL.Path == "/" {
if b := auth(w, r); b {
htasks(self.gls, self.glps, w, r)
}
return
}
if debugmode && r.Method == "GET" {
switch r.URL.Path {
case "/debug/pprof/cmdline":
if b := auth(w, r); b {
pprof.Cmdline(w, r)
}
return
case "/debug/pprof/profile":
if b := auth(w, r); b {
pprof.Profile(w, r)
}
return
case "/debug/pprof/symbol":
if b := auth(w, r); b {
pprof.Symbol(w, r)
}
return
// case "/debug/vars":
// expvarHandler(w, r)
// return
}
if strings.HasPrefix(r.URL.Path, "/debug/pprof/") {
if b := auth(w, r); b {
pprof.Index(w, r)
}
return
}
}
cors(w, r)
for n, route := range self.glsroute {
match, pmap := route.Match(r.Method, r.URL.Path)
if match == NoMatch {
continue
}
// log.Infoln("Test", n, r.URL.Path, match, pmap, "OK")
route.g.exec(n, w, r, pmap)
return
}
http.NotFound(w, r)
}
func setupHandlers(sources []api.Source, sink sinks.ExternalSinkManager, m manager.Manager) http.Handler {
// Make API handler.
wsContainer := restful.NewContainer()
a := v1.NewApi(m)
a.Register(wsContainer)
// Validation/Debug handler.
handleValidate := func(req *restful.Request, resp *restful.Response) {
err := validate.HandleRequest(resp, sources, sink)
if err != nil {
fmt.Fprintf(resp, "%s", err)
}
}
ws := new(restful.WebService).
Path("/validate").
Produces("text/plain")
ws.Route(ws.GET("").To(handleValidate)).
Doc("get validation information")
wsContainer.Add(ws)
// TODO(jnagal): Add a main status page.
// Redirect root to /validate
redirectHandler := http.RedirectHandler(validate.ValidatePage, http.StatusTemporaryRedirect)
handleRoot := func(req *restful.Request, resp *restful.Response) {
redirectHandler.ServeHTTP(resp, req.Request)
}
ws = new(restful.WebService)
ws.Route(ws.GET("/").To(handleRoot))
wsContainer.Add(ws)
handlePprofEndpoint := func(req *restful.Request, resp *restful.Response) {
name := strings.TrimPrefix(req.Request.URL.Path, pprofBasePath)
switch name {
case "profile":
pprof.Profile(resp, req.Request)
case "symbol":
pprof.Symbol(resp, req.Request)
case "cmdline":
pprof.Cmdline(resp, req.Request)
default:
pprof.Index(resp, req.Request)
}
}
// Setup pporf handlers.
ws = new(restful.WebService).Path(pprofBasePath)
ws.Route(ws.GET("/{subpath:*}").To(func(req *restful.Request, resp *restful.Response) {
handlePprofEndpoint(req, resp)
})).Doc("pprof endpoint")
wsContainer.Add(ws)
return wsContainer
}
func (*Pprof) Index(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
switch p.ByName("name") {
case "profile":
pprof.Profile(w, r)
case "symbol":
pprof.Symbol(w, r)
case "trace":
pprof.Trace(w, r)
case "cmdline":
pprof.Cmdline(w, r)
default:
pprof.Index(w, r)
}
}
func (this *ProfController) Get() {
ptype := this.Ctx.Params[":pp"]
if ptype == "" {
pprof.Index(this.Ctx.ResponseWriter, this.Ctx.Request)
} else if ptype == "cmdline" {
pprof.Cmdline(this.Ctx.ResponseWriter, this.Ctx.Request)
} else if ptype == "profile" {
pprof.Profile(this.Ctx.ResponseWriter, this.Ctx.Request)
} else if ptype == "symbol" {
pprof.Symbol(this.Ctx.ResponseWriter, this.Ctx.Request)
} else {
pprof.Index(this.Ctx.ResponseWriter, this.Ctx.Request)
}
this.Ctx.ResponseWriter.WriteHeader(200)
}
// Handler routes the pprof pages using httprouter
func Handler(w http.ResponseWriter, r *http.Request) {
p := context.Get(r, "params").(httprouter.Params)
switch p.ByName("pprof") {
case "/cmdline":
pprof.Cmdline(w, r)
case "/profile":
pprof.Profile(w, r)
case "/symbol":
pprof.Symbol(w, r)
default:
pprof.Index(w, r)
}
}
func (this *ProfController) Get() {
switch this.Ctx.Params[":pp"] {
default:
pprof.Index(this.Ctx.ResponseWriter, this.Ctx.Request)
case "":
pprof.Index(this.Ctx.ResponseWriter, this.Ctx.Request)
case "cmdline":
pprof.Cmdline(this.Ctx.ResponseWriter, this.Ctx.Request)
case "profile":
pprof.Profile(this.Ctx.ResponseWriter, this.Ctx.Request)
case "symbol":
pprof.Symbol(this.Ctx.ResponseWriter, this.Ctx.Request)
}
this.Ctx.ResponseWriter.WriteHeader(200)
}
// ServeHTTP responds to HTTP request to the handler.
func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// FIXME(benbjohnson): Add pprof enabled flag.
if strings.HasPrefix(r.URL.Path, "/debug/pprof") {
switch r.URL.Path {
case "/debug/pprof/cmdline":
pprof.Cmdline(w, r)
case "/debug/pprof/profile":
pprof.Profile(w, r)
case "/debug/pprof/symbol":
pprof.Symbol(w, r)
default:
pprof.Index(w, r)
}
return
}
h.mux.ServeHTTP(w, r)
}
// ServeHTTP responds to HTTP request to the handler.
func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
if strings.HasPrefix(r.URL.Path, "/debug/pprof") {
switch r.URL.Path {
case "/debug/pprof/cmdline":
pprof.Cmdline(w, r)
case "/debug/pprof/profile":
pprof.Profile(w, r)
case "/debug/pprof/symbol":
pprof.Symbol(w, r)
default:
pprof.Index(w, r)
}
} else {
}
return
}
func (s *httpServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
switch req.URL.Path {
case "/ping":
s.pingHandler(w, req)
case "/get":
s.getHandler(w, req)
case "/mget":
s.mgetHandler(w, req)
case "/fwmatch":
s.fwmatchHandler(w, req)
case "/range":
s.rangeHandler(w, req)
case "/stats":
s.statsHandler(w, req)
case "/reload":
s.reloadHandler(w, req)
// case "/exit":
// s.exitHandler(w, req)
case "/debug/pprof":
httpprof.Index(w, req)
case "/debug/pprof/cmdline":
httpprof.Cmdline(w, req)
case "/debug/pprof/symbol":
httpprof.Symbol(w, req)
case "/debug/pprof/heap":
httpprof.Handler("heap").ServeHTTP(w, req)
case "/debug/pprof/goroutine":
httpprof.Handler("goroutine").ServeHTTP(w, req)
case "/debug/pprof/profile":
httpprof.Profile(w, req)
case "/debug/pprof/block":
httpprof.Handler("block").ServeHTTP(w, req)
case "/debug/pprof/threadcreate":
httpprof.Handler("threadcreate").ServeHTTP(w, req)
default:
log.Printf("ERROR: 404 %s", req.URL.Path)
http.NotFound(w, req)
}
}
func (rh *RequestHandler) pprofHTTP(w http.ResponseWriter, r *http.Request) bool {
if !rh.ServerConfig.Debug {
return false
}
switch r.RequestURI {
case "/debug/pprof/cmdline":
pprof.Cmdline(w, r)
return true
case "/debug/pprof/profile":
pprof.Profile(w, r)
return true
case "/debug/pprof/heap":
h := pprof.Handler("heap")
h.ServeHTTP(w, r)
return true
case "/debug/pprof/symbol":
pprof.Symbol(w, r)
return true
default:
return false
}
return false
}
func (s *httpServer) debugRouter(w http.ResponseWriter, req *http.Request) error {
switch req.URL.Path {
case "/debug/pprof":
httpprof.Index(w, req)
case "/debug/pprof/cmdline":
httpprof.Cmdline(w, req)
case "/debug/pprof/symbol":
httpprof.Symbol(w, req)
case "/debug/pprof/heap":
httpprof.Handler("heap").ServeHTTP(w, req)
case "/debug/pprof/goroutine":
httpprof.Handler("goroutine").ServeHTTP(w, req)
case "/debug/pprof/profile":
httpprof.Profile(w, req)
case "/debug/pprof/block":
httpprof.Handler("block").ServeHTTP(w, req)
case "/debug/pprof/threadcreate":
httpprof.Handler("threadcreate").ServeHTTP(w, req)
default:
return fmt.Errorf("404 %s", req.URL.Path)
}
return nil
}