Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/victorspringer/http-cache
High performance Golang HTTP middleware for server-side application layer caching, ideal for REST APIs
https://github.com/victorspringer/http-cache
cache fastest http middleware
Last synced: 9 days ago
JSON representation
High performance Golang HTTP middleware for server-side application layer caching, ideal for REST APIs
- Host: GitHub
- URL: https://github.com/victorspringer/http-cache
- Owner: victorspringer
- License: mit
- Created: 2018-04-14T11:10:03.000Z (about 6 years ago)
- Default Branch: master
- Last Pushed: 2024-05-23T14:33:24.000Z (about 1 month ago)
- Last Synced: 2024-06-18T13:55:59.302Z (18 days ago)
- Topics: cache, fastest, http, middleware
- Language: Go
- Homepage: https://godoc.org/github.com/victorspringer/http-cache
- Size: 304 KB
- Stars: 333
- Watchers: 6
- Forks: 61
- Open Issues: 10
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Lists
- awesome-stars - victorspringer/http-cache - High performance Golang HTTP middleware for server-side application layer caching, ideal for REST APIs (Go)
README
# http-cache
[](https://travis-ci.org/victorspringer/http-cache) [](https://coveralls.io/github/victorspringer/http-cache?branch=master) [](https://godoc.org/github.com/victorspringer/http-cache)
This is a high performance Golang HTTP middleware for server-side application layer caching, ideal for REST APIs.
It is simple, super fast, thread safe and gives the possibility to choose the adapter (memory, Redis, DynamoDB etc).
The memory adapter minimizes GC overhead to near zero and supports some options of caching algorithms (LRU, MRU, LFU, MFU). This way, it is able to store plenty of gigabytes of responses, keeping great performance and being free of leaks.
## Getting Started
### Installation
`go get github.com/victorspringer/http-cache`
### Usage
This is an example of use with the memory adapter:
```go
package main
import (
"log"
"net/http"
"os"
"time"
"github.com/victorspringer/http-cache"
"github.com/victorspringer/http-cache/adapter/memory"
)
func example(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("Ok"))
}
func main() {
memcached, err := memory.NewAdapter(
memory.AdapterWithAlgorithm(memory.LRU),
memory.AdapterWithCapacity(10000000),
)
if err != nil {
log.Fatal(err)
}
cacheClient, err := cache.NewClient(
cache.ClientWithAdapter(memcached),
cache.ClientWithTTL(10 * time.Minute),
cache.ClientWithRefreshKey("opn"),
)
if err != nil {
log.Fatal(err)
}
handler := http.HandlerFunc(example)
http.Handle("/", cacheClient.Middleware(handler))
http.ListenAndServe(":8080", nil)
}
```
Example of Client initialization with Redis adapter:
```go
import (
"github.com/victorspringer/http-cache"
"github.com/victorspringer/http-cache/adapter/redis"
)
...
ringOpt := &redis.RingOptions{
Addrs: map[string]string{
"server": ":6379",
},
}
cacheClient, err := cache.NewClient(
cache.ClientWithAdapter(redis.NewAdapter(ringOpt)),
cache.ClientWithTTL(10 * time.Minute),
cache.ClientWithRefreshKey("opn"),
)
...
```
## Benchmarks
The benchmarks were based on [allegro/bigache](https://github.com/allegro/bigcache) tests and used to compare it with the http-cache memory adapter.
The tests were run using an Intel i5-2410M with 8GB RAM on Arch Linux 64bits.
The results are shown below:
### Writes and Reads
```bash
cd adapter/memory/benchmark
go test -bench=. -benchtime=10s ./... -timeout 30m
BenchmarkHTTPCacheMamoryAdapterSet-4 5000000 343 ns/op 172 B/op 1 allocs/op
BenchmarkBigCacheSet-4 3000000 507 ns/op 535 B/op 1 allocs/op
BenchmarkHTTPCacheMamoryAdapterGet-4 20000000 146 ns/op 0 B/op 0 allocs/op
BenchmarkBigCacheGet-4 3000000 343 ns/op 120 B/op 3 allocs/op
BenchmarkHTTPCacheMamoryAdapterSetParallel-4 10000000 223 ns/op 172 B/op 1 allocs/op
BenchmarkBigCacheSetParallel-4 10000000 291 ns/op 661 B/op 1 allocs/op
BenchmarkHTTPCacheMemoryAdapterGetParallel-4 50000000 56.1 ns/op 0 B/op 0 allocs/op
BenchmarkBigCacheGetParallel-4 10000000 163 ns/op 120 B/op 3 allocs/op
```
http-cache writes are slightly faster and reads are much more faster.
### Garbage Collection Pause Time
```bash
cache=http-cache go run benchmark_gc_overhead.go
Number of entries: 20000000
GC pause for http-cache memory adapter: 2.445617ms
cache=bigcache go run benchmark_gc_overhead.go
Number of entries: 20000000
GC pause for bigcache: 7.43339ms
```
http-cache memory adapter takes way less GC pause time, that means smaller GC overhead.
## Roadmap
- Make it compliant with RFC7234
- Add more middleware configuration (cacheable status codes, paths etc)
- Develop gRPC middleware
- Develop Badger adapter
- Develop DynamoDB adapter
- Develop MongoDB adapter
## Godoc Reference
- [http-cache](https://godoc.org/github.com/victorspringer/http-cache)
- [Memory adapter](https://godoc.org/github.com/victorspringer/http-cache/adapter/memory)
- [Redis adapter](https://godoc.org/github.com/victorspringer/http-cache/adapter/redis)
## License
http-cache is released under the [MIT License](https://github.com/victorspringer/http-cache/blob/master/LICENSE).