Gearbox :gear: is a web framework written in Go with a focus on high performance

Describe the bug

package main

import (
	"log"

	"github.com/gogearbox/gearbox"
)

func main() {
	gb := gearbox.New()
	logMiddleware := func(ctx gearbox.Context) {
		log.Printf("log message!")
		ctx.Next()
	}
	gb.Use(logMiddleware)
	routes := []*gearbox.Route{
		gb.Get("/id", func(ctx gearbox.Context) {
			ctx.SendString("User X")
		}),
		gb.Delete("/del", func(ctx gearbox.Context) {
			ctx.SendString("Deleted")
		}),
	}

	accountRoutes := gb.Group("/account", routes)
	gb.Group("/api", accountRoutes)
	gb.Start(":3000")
}

go run main.go curl http://localhost:3000/api/account/id output: Deleted To Reproduce Steps to reproduce the behavior:

Expected behavior A clear and concise description of what you expected to happen.

Actual behavior curl http://localhost:3000/api/account/id

My x86 system result "Deleted" but my amd64 system result "User X" , it's so strange

Version/Commit gear1.1.1 , go1.15.7

Is your feature request related to a problem? Please describe. It would be great to customize the error handlers that are used for the various potential errors. For example a simple HTML 500-error or some additional logic.

Describe the solution you'd like Something akin to NotFound() like NotAllowed(), InternalServerError(), IAmATeapot()

I'm curious about the choice for a Ternary Search Tree instead of just a normal map. I wrote a quick benchmark an no matter how I configure it the map always uses 90% less memory and is 10% to 500% faster depending on the hit rate. Do you have some benchmark to show why it is better for your case?

package main

import (
	"container/list"
	"math/rand"
	"runtime"
	"testing"
)

// Basic Implementation for Ternary Search Tree (TST)

// tst returns Ternary Search Tree
type tst interface {
	Set(word []byte, value interface{})
	Get(word []byte) interface{}
	GetString(word string) interface{}
}

// Ternary Search Tree node that holds a single character and value if there is
type tstNode struct {
	lower  *tstNode
	higher *tstNode
	equal  *tstNode
	char   byte
	value  interface{}
}

// newTST returns Ternary Search Tree
func newTST() tst {
	return &tstNode{}
}

// Set adds a value to provided key
func (t *tstNode) Set(key []byte, value interface{}) {
	if len(key) < 1 {
		return
	}

	t.insert(t, key, 0, value)
}

// Get gets the value of provided key if it's existing, otherwise returns nil
func (t *tstNode) Get(key []byte) interface{} {
	length := len(key)
	if length < 1 || t == nil {
		return nil
	}
	lastElm := length - 1

	n := t
	idx := 0
	char := key[idx]
	for n != nil {
		if char < n.char {
			n = n.lower
		} else if char > n.char {
			n = n.higher
		} else {
			if idx == lastElm {
				return n.value
			}

			idx++
			n = n.equal
			char = key[idx]
		}
	}
	return nil
}

// Get gets the value of provided key (string) if it's existing, otherwise returns nil
func (t *tstNode) GetString(key string) interface{} {
	return t.Get([]byte(key))
}

// insert is an internal method for inserting a []byte with value in TST
func (t *tstNode) insert(n *tstNode, key []byte, index int, value interface{}) *tstNode {
	char := key[index]
	lastElm := len(key) - 1

	if n == nil {
		n = &tstNode{char: char}
	}

	if char < n.char {
		n.lower = t.insert(n.lower, key, index, value)
	} else if char > n.char {
		n.higher = t.insert(n.higher, key, index, value)
	} else {
		if index == lastElm {
			n.value = value
		} else {
			n.equal = t.insert(n.equal, key, index+1, value)
		}
	}

	return n
}

// RandBytes generates random string from English letters
func RandBytes() []byte {
	const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
	b := make([]byte, rand.Intn(100))
	for i := range b {
		b[i] = letterBytes[rand.Intn(len(letterBytes))]
	}
	return b
}

var (
	keys = make([][]byte, 1000)
	T    tst
	M    = make(map[string]interface{})

	Sink interface{}
)

func init() {
	T = newTST()
	rand.Seed(0)

	for i := 0; i < len(keys); i++ {
		keys[i] = RandBytes()
	}

	rand.Seed(0)
	var b, a runtime.MemStats
	runtime.ReadMemStats(&b)
	for i := 0; i < 500; i++ { // Only fill half of the keys so we get a 50% hit rate.
		T.Set(keys[i], &list.Element{})
	}
	runtime.ReadMemStats(&a)
	println(a.Alloc - b.Alloc)

	rand.Seed(0)
	runtime.ReadMemStats(&b)
	for i := 0; i < 500; i++ { // Only fill half of the keys so we get a 50% hit rate.
		M[string(keys[i])] = &list.Element{}
	}
	runtime.ReadMemStats(&a)
	println(a.Alloc - b.Alloc)
}

func BenchmarkTST(b *testing.B) {
	for n := 0; n < b.N; n++ {
		Sink = T.Get(keys[(n*31)%len(keys)]) // Lookup a semi random key (using rand.Intn is too heavy here compared to the operation we are benchmarking).
	}
}

func BenchmarkMap(b *testing.B) {
	for n := 0; n < b.N; n++ {
		Sink = M[string(keys[(n*31)%len(keys)])] // Lookup a semi random key (using rand.Intn is too heavy here compared to the operation we are benchmarking).
	}
}

Hi,

I'm leading a benchmarking project => https://github.com/the-benchmarker/web-frameworks

The purpose of this project is to compare performances (other indicators will come), based on a fairest, as we can, comparison for go frameworks (comparing on the same version, production-grade environments, same compilation options ...).

Do you mind that I (or any member) add gearbox ? :heart:

Regards,

Fixes #11

Changes proposed in this pull request:

• Use []bytes instead of strings in router
• Improve route matching
• Updating tests according to changes

Allow user to specify parameters in paths while adding routes (e.g. gearbox.Get("/user/:name, ...)).

Discussions / suggestions is open here

• The proper delimiter (:name, or {name})
• How these parameters will be passed to handler

I'd love to use the project because of it's awesome performance but we need Prometheus metrics for our production env so is it possible for you to write Prometheus middlewares for it?

I initialize routes like this:

func (h *HttpSrv) createRoutes() {
	h.g.Get("/dsp/cpc/:sspId", h.handleGetBids)
	h.g.Post("/dsp/cpc/:sspId", h.handlePostBids)

	h.g.Get("/dsp-native/cpc/:sspId", h.handleNativeGetBids)
	h.g.Post("/dsp-native/cpc/:sspId", h.handleNativePostBids)

	h.g.Get("/dsp-popunder/cpc/:sspId", h.handlePopunderGetBids)
	h.g.Post("/dsp-popunder/cpc/:sspId", h.handlePopunderPostBids)
}

func (h *HttpSrv) handleGetBids(ctx gearbox.Context) {
	mw, ok := sspinfo.GetSspProcessorsPool().GetPushProcessor(ctx.Param("sspId"))
	if ok {
		mw.ExecQueryParamsHandler(ctx)
	} else {
		ctx.Status(gearbox.StatusNotFound)
	}
}

And catching the next panic:

panic: runtime error: slice bounds out of range [1:0]
goroutine 2027 [running]:
github.com/gogearbox/gearbox.(*node).matchRoute(0xc000557c00, 0xc031aa2900, 0x0, 0xc030b9b320, 0xc02e463f68, 0xc032ece400, 0x3)
	/go/pkg/mod/github.com/gogearbox/[email protected]/tree.go:134 +0x289
github.com/gogearbox/gearbox.(*router).Handler(0xc0005d0c80, 0xc0323d7400)
	/go/pkg/mod/github.com/gogearbox/[email protected]/router.go:163 +0x745
github.com/valyala/fasthttp.(*Server).serveConn(0xc02e54c000, 0xa69b38, 0xc031106420, 0x0, 0x0)
	/go/pkg/mod/github.com/valyala/[email protected]/server.go:2193 +0x128e
github.com/valyala/fasthttp.(*workerPool).workerFunc(0xc02e468640, 0xc032c9b0a0)
	/go/pkg/mod/github.com/valyala/[email protected]/workerpool.go:223 +0xba
github.com/valyala/fasthttp.(*workerPool).getCh.func1(0xc02e468640, 0xc032c9b0a0, 0x905520, 0xc032c9b0a0)
	/go/pkg/mod/github.com/valyala/[email protected]/workerpool.go:195 +0x35
created by github.com/valyala/fasthttp.(*workerPool).getCh
	/go/pkg/mod/github.com/valyala/[email protected]/workerpool.go:194 +0x11f

What the reason could be?

Is your feature request related to a problem? Please describe. I have a middleware that checks and parse the JWT. I would like to pass from that middleware to the handler the parsed JWT so I don't need to parse it again. I saw that the fiber has this feature but I didn't saw anything related here.

Describe the solution you'd like Be able to set in context some data that will be available in the next middleware or handler

First of all I am not sure maybe there is an work around for that but i cant find it.

Here is the use case: I like to use opencensus.io for request tracking and prometheus for metrics export. If you are using standard net/http you can do that like this

import "contrib.go.opencensus.io/exporter/prometheus"

// Then create the actual exporter
pe, err := prometheus.NewExporter(prometheus.Options{
    Namespace: "demo",
})

pe is http.handler

Probably if you are using standalone fasthttp you can use fasthttpadaptor to wrap the net/http handler. Are there an option to attach fasthttp.RequestHandler directly to the gearbox ?

I think we need to implement something like Active Job on Rails for job scheduling

• We need to write some test for the worker's implementation
• We need to implement an adaptor for the FastHttp worker-pool

Describe the bug Just above this part of your homepage the link to your documentation point to an unsafe location:

To Reproduce Just click the provided link

Expected behavior Your doc

Actual behavior Some redirections to something not related to gearbox

Bumps github.com/valyala/fasthttp from 1.40.0 to 1.43.0.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.