// How to use Revel properly with Defer Panic client library func init() { dps := deferstats.NewClient("z57z3xsEfpqxpr0dSte0auTBItWBYa1c") go dps.CaptureStats() // Filters is the default set of global filters. revel.Filters = []revel.Filter{ middleware.Wrapper(dps), revel.RouterFilter, // Use the routing table to select the right Action revel.FilterConfiguringFilter, // A hook for adding or removing per-Action filters. revel.ParamsFilter, // Parse parameters into Controller.Params. revel.SessionFilter, // Restore and write the session cookie. revel.FlashFilter, // Restore and write the flash cookie. revel.ValidationFilter, // Restore kept validation errors and save new ones from cookie. revel.I18nFilter, // Resolve the requested language HeaderFilter, // Add some security based headers revel.InterceptorFilter, // Run interceptors around the action. revel.CompressFilter, // Compress the result. revel.ActionInvoker, // Invoke the action. } // register startup functions with OnAppStart // ( order dependent ) // revel.OnAppStart(InitDB) // revel.OnAppStart(FillCache) }
// How to use Echo properly with Defer Panic client library func main() { dps := deferstats.NewClient("z57z3xsEfpqxpr0dSte0auTBItWBYa1c") go dps.CaptureStats() // Echo instance e := echo.New() e.Use(middleware.Wrapper(dps)) // Routes e.Get("/fast", func(c *echo.Context) error { return c.String(http.StatusOK, "Hello, world!\n") }) e.Get("/slow", func(c *echo.Context) error { time.Sleep(5 * time.Second) return c.String(http.StatusOK, "Hello, world!\n") }) e.Get("/panic", func(c *echo.Context) error { panic("There is no need for panic") return c.String(http.StatusOK, "Hello, world!\n") }) // Start server e.Run(":3000") }
// How to use Martini properly with Defer Panic client library func main() { dps := deferstats.NewClient("z57z3xsEfpqxpr0dSte0auTBItWBYa1c") go dps.CaptureStats() m := martini.New() r := martini.NewRouter() r.Get("/panic", func() string { panic("There is no need for panic") return "Hello world!" }) r.Get("/slow", func() string { time.Sleep(5 * time.Second) return "Hello world!" }) r.Get("/fast", func() string { return "Hello world!" }) m.MapTo(r, (*martini.Routes)(nil)) m.Action(r.Handle) m.Use(middleware.Wrapper(dps)) m.RunOnAddr(":3000") }
func TestContextSOAHandler(t *testing.T) { deferstats.ResetHTTPStats() dps := deferstats.NewClient("token") mux := http.NewServeMux() post := ContextHandlerFunc(func(ctx context.Context, w http.ResponseWriter, r *http.Request) { r.ParseForm() dpsi := r.Header.Get("X-dpparentspanid") okey := r.FormValue("other_key") if dpsi != "8103318854963911860" { t.Error("span not accessible") } if okey != "2" { t.Error("other_key not accessible") } }) mux.Handle("/", NewWrapper(ContextHandlerFunc(post), dps)) // set listener l, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { t.Error("http not listening") } dps.SetStatsURL("http://" + l.Addr().String() + "/") go http.Serve(l, mux) lurl := "http://" + l.Addr().String() + "/" data := url.Values{} data.Set("other_key", "2") client := &http.Client{} r, err := http.NewRequest("POST", lurl, bytes.NewBufferString(data.Encode())) if err != nil { panic(err) } r.Header.Add("Content-Type", "application/x-www-form-urlencoded") r.Header.Add("Content-Length", strconv.Itoa(len(data.Encode()))) r.Header.Add("X-dpparentspanid", "8103318854963911860") resp, err := client.Do(r) if err != nil { panic(err) } defer resp.Body.Close() if len(deferstats.GetHTTPStats()) == 0 { t.Error("should have a http in the list") } if deferstats.GetHTTPStats()[0].ParentSpanId != 8103318854963911860 { t.Error("not tracking our parent_span_id") } }
func main() { dps := deferstats.NewClient("v00L0K6CdKjE4QwX5DL1iiODxovAHUfo") go dps.CaptureStats() http.HandleFunc("/zeus", dps.HTTPHandlerFunc(handler)) http.ListenAndServe(":3000", nil) }
func main() { dps := deferstats.NewClient("z57z3xsEfpqxpr0dSte0auTBItWBYa1c") go dps.CaptureStats() http.Handle("/panic", middleware.NewWrapper(context.Background(), middleware.ContextHandlerFunc(panicHandler), dps)) http.Handle("/slow", middleware.NewWrapper(context.Background(), middleware.ContextHandlerFunc(slowHandler), dps)) http.Handle("/fast", middleware.NewWrapper(context.Background(), middleware.ContextHandlerFunc(fastHandler), dps)) http.Handle("/spanId", middleware.NewWrapper(context.Background(), middleware.ContextHandlerFunc(spanIDHandler), dps)) http.ListenAndServe(":3000", nil) }
func TestHTTPContextPostHandler(t *testing.T) { dps := deferstats.NewClient("token") mux := http.NewServeMux() post := ContextHandlerFunc(func(ctx context.Context, w http.ResponseWriter, r *http.Request) { body, err := ioutil.ReadAll(r.Body) if err != nil { panic(err) } var tj TestContextJSON err = json.Unmarshal(body, &tj) if err != nil { panic(err) } if tj.Title != "sample title in json" { t.Error("not parsing the POST body correctly") } }) mux.Handle("/", NewWrapper(ContextHandlerFunc(post), dps)) // set listener l, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { t.Error("http not listening") } dps.SetStatsURL("http://" + l.Addr().String() + "/") go http.Serve(l, mux) lurl := "http://" + l.Addr().String() + "/" var jsonStr = []byte(`{"Title":"sample title in json"}`) req, err := http.NewRequest("POST", lurl, bytes.NewBuffer(jsonStr)) if err != nil { panic(err) } req.Header.Set("X-Custom-Header", "some header") req.Header.Set("Content-Type", "application/json") client := &http.Client{} resp, err := client.Do(req) if err != nil { panic(err) } defer resp.Body.Close() }
// How to use Logrus properly with Defer Panic client library func main() { dps := deferstats.NewClient("z57z3xsEfpqxpr0dSte0auTBItWBYa1c") go dps.CaptureStats() log := logrus.New() hook, err := middleware.NewDPHook(dps) if err == nil { log.Hooks.Add(hook) } log.Error("Error is here!") log.Fatal("Fatal is here!") log.Panic("Panic is here!") }
// How to use Falcore properly with Defer Panic client library func main() { dps := deferstats.NewClient("z57z3xsEfpqxpr0dSte0auTBItWBYa1c") go dps.CaptureStats() // create pipeline pipeline := falcore.NewPipeline() // add upstream pipeline stages var filter helloFilter pipeline.Upstream.PushBack(filter) // create server on port 0 server := falcore.NewServer(0, pipeline) // start the server // this is normally blocking forever unless you send lifecycle commands http.ListenAndServe(":3000", middleware.Wrapper(dps, server)) }
func TestHTTPContextHeaderHandler(t *testing.T) { dps := deferstats.NewClient("token") mux := http.NewServeMux() post := ContextHandlerFunc(func(ctx context.Context, w http.ResponseWriter, r *http.Request) { if r.Header.Get("X-Custom-Header") != "some header" { t.Error("headers not being passed through") } if r.Header.Get("Content-Type") != "application/json" { t.Error("headers not being passed through") } }) mux.Handle("/", NewWrapper(ContextHandlerFunc(post), dps)) // set listener l, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { t.Error("http not listening") } dps.SetStatsURL("http://" + l.Addr().String() + "/") go http.Serve(l, mux) lurl := "http://" + l.Addr().String() + "/" var jsonStr = []byte(`{"Title":"sample title in json"}`) req, err := http.NewRequest("POST", lurl, bytes.NewBuffer(jsonStr)) if err != nil { panic(err) } req.Header.Set("X-Custom-Header", "some header") req.Header.Set("Content-Type", "application/json") client := &http.Client{} resp, err := client.Do(req) if err != nil { panic(err) } defer resp.Body.Close() }
// How to use Gorilla properly with Defer Panic client library func main() { dps := deferstats.NewClient("z57z3xsEfpqxpr0dSte0auTBItWBYa1c") go dps.CaptureStats() r := mux.NewRouter() r.HandleFunc("/slow", func(w http.ResponseWriter, r *http.Request) { time.Sleep(5 * time.Second) w.Write([]byte("Hello, world!")) }) r.HandleFunc("/fast", func(w http.ResponseWriter, r *http.Request) { w.Write([]byte("Hello, world!")) }) r.HandleFunc("/panic", func(w http.ResponseWriter, r *http.Request) { panic("There is no need for panic") w.Write([]byte("Hello, world!")) }) http.ListenAndServe(":3000", middleware.Wrapper(dps, r)) }
func init() { parseJsonFile("etc/config.json", &Config) analyticsCode = getDefaultCode(Config.AnalyticsFile) configGithubAuth() if Config.DB == "" { fmt.Println("数据库地址还没有配置,请到config.json内配置db字段.") os.Exit(1) } session, err := mgo.Dial(Config.DB) if err != nil { panic(err) fmt.Println("MongoDB连接失败:", err.Error()) os.Exit(1) } session.SetMode(mgo.Monotonic, true) db := session.DB("gopher") store = sessions.NewCookieStore([]byte(Config.CookieSecret)) utils = &Utils{} // 如果没有status,创建 var status Status c := db.C(STATUS) err = c.Find(nil).One(&status) if err != nil { c.Insert(&Status{ Id_: bson.NewObjectId(), UserCount: 0, TopicCount: 0, ReplyCount: 0, UserIndex: 0, }) } // 检查是否有超级账户设置 var superusers []string for _, username := range strings.Split(Config.Superusers, ",") { username = strings.TrimSpace(username) if username != "" { superusers = append(superusers, username) } } if len(superusers) == 0 { fmt.Println("你没有设置超级账户,请在config.json中的superusers中设置,如有多个账户,用逗号分开") } c = db.C(USERS) var users []User c.Find(bson.M{"issuperuser": true}).All(&users) // 如果mongodb中的超级用户不在配置文件中,取消超级用户 for _, user := range users { if !stringInArray(superusers, user.Username) { c.Update(bson.M{"_id": user.Id_}, bson.M{"$set": bson.M{"issuperuser": false}}) } } // 设置超级用户 for _, username := range superusers { c.Update(bson.M{"username": username, "issuperuser": false}, bson.M{"$set": bson.M{"issuperuser": true}}) } // 生成users.json字符串 generateUsersJson(db) if Config.DeferPanicApiKey != "" { dps = deferstats.NewClient(Config.DeferPanicApiKey) } ACCESS_KEY = Config.QiniuAccessKey SECRET_KEY = Config.QiniuSecretKey }
func main() { var ( port = 3001 redisDatabase = 0 redisPoolSize = 10 clientID = "" clientSecret = "" hashKey = "randomishstringthatsi32charslong" blockKey = "randomishstringthatsi32charslong" deferPanicKey = "" ) flag.IntVar(&port, "port", port, "Port to start the server on") flag.IntVar(&procs, "procs", 1, "Number of CPU processors (0 to use max)") flag.BoolVar(&debug, "debug", false, "Debug mode") flag.StringVar( &redisURL, "redisURL", redisURL, "Redis URL to tcp connect to") flag.StringVar( &staticPrefix, "staticPrefix", staticPrefix, "Prefix in front of static assets in HTML") flag.IntVar(&redisDatabase, "redisDatabase", redisDatabase, "Redis database number to connect to") flag.StringVar( &clientID, "clientID", clientID, "OAuth Client ID") flag.StringVar( &clientSecret, "clientSecret", clientSecret, "OAuth Client Secret") flag.BoolVar(&usingHTTPS, "usingHTTPS", usingHTTPS, "Whether requests are made under HTTPS") flag.StringVar( &hashKey, "hashKey", hashKey, "HMAC hash key to use for encoding cookies") flag.StringVar( &blockKey, "blockKey", blockKey, "Block key to encrypt cookie values") flag.StringVar( &deferPanicKey, "deferPanicKey", deferPanicKey, "Auth key for deferpanic.com") flag.Parse() dfs := deferstats.NewClient(deferPanicKey) if deferPanicKey == "" { dfs.SetnoPost(true) } go dfs.CaptureStats() oauthConf.ClientID = clientID oauthConf.ClientSecret = clientSecret sCookie = securecookie.New([]byte(hashKey), []byte(blockKey)) log.Println("REDIS DATABASE:", redisDatabase) log.Println("DEBUG MODE:", debug) log.Println("STATIC PREFIX:", staticPrefix) if !debug { redisPoolSize = 100 } // Figuring out how many processors to use. maxProcs := runtime.NumCPU() if procs == 0 { procs = maxProcs } else if procs < 0 { panic("PROCS < 0") } else if procs > maxProcs { panic(fmt.Sprintf("PROCS > max (%v)", maxProcs)) } log.Println("PROCS:", procs) runtime.GOMAXPROCS(procs) renderer = render.New(render.Options{ IndentJSON: debug, IsDevelopment: debug, }) df := func(network, addr string) (*redis.Client, error) { client, err := redis.Dial(network, addr) if err != nil { return nil, err } err = client.Cmd("SELECT", redisDatabase).Err if err != nil { return nil, err } // if err = client.Cmd("AUTH", "SUPERSECRET").Err; err != nil { // client.Close() // return nil, err // } return client, nil } var err error redisPool, err = pool.NewCustomPool("tcp", redisURL, redisPoolSize, df) errorHandler(err) mux := mux.NewRouter() mux.HandleFunc("/", dfs.HTTPHandler(indexHandler)).Methods("GET", "HEAD") mux.HandleFunc("/v1/ping", dfs.HTTPHandler(pingHandler)).Methods("GET", "HEAD") mux.HandleFunc("/v1", dfs.HTTPHandler(fetchHandler)).Methods("GET", "HEAD") mux.HandleFunc("/v1", dfs.HTTPHandler(updateHandler)).Methods("POST", "PUT") mux.HandleFunc("/v1", dfs.HTTPHandler(deleteHandler)).Methods("DELETE") mux.HandleFunc("/v1/stats", dfs.HTTPHandler(privateStatsHandler)).Methods("GET") mux.HandleFunc("/v1/flush", dfs.HTTPHandler(flushHandler)).Methods("DELETE") mux.HandleFunc("/v1/bulk", dfs.HTTPHandler(bulkHandler)).Methods("POST", "PUT") mux.HandleFunc("/login", dfs.HTTPHandler(handleGitHubLogin)).Methods("GET") mux.HandleFunc("/logout", dfs.HTTPHandler(logoutHandler)).Methods("GET", "POST") mux.HandleFunc("/github_oauth_cb", dfs.HTTPHandler(handleGitHubCallback)).Methods("GET") mux.HandleFunc("/domainkeys/new", domainkeyNewHandler).Methods("POST") mux.HandleFunc("/domainkeys/delete", domainkeyDeleteHandler).Methods("POST") n := negroni.Classic() n.UseHandler(mux) n.Run(fmt.Sprintf(":%d", port)) }
// NewLogger configures defer panic error and starts capturing stats. // It looks for DEFERPANIC_KEY, // DEVERPANIC_ENVIRONMENT and DEFERPANIC_APPGROUP environment vars func NewLogger() { dfs = deferstats.NewClient(os.Getenv("DEFERPANIC_API_KEY")) dfs.Setenvironment(os.Getenv("DEFERPANIC_ENVIRONMENT")) dfs.SetappGroup(os.Getenv("DEFERPANIC_APPGROUP")) go dfs.CaptureStats() }