Updated deps

Signed-off-by: Vishal Rana <[email protected]>

Author: vishr

Gopkg.lock

@@ -29,6 +29,10 @@
   name = "github.com/go-resty/resty"
   version = "1.5.0"
 
+[[constraint]]
+  name = "github.com/labstack/echo"
+  version = "3.3.5"
+
 [[constraint]]
   name = "github.com/labstack/gommon"
   version = "0.2.5"

Gopkg.toml

@@ -39,4 +39,4 @@ From terminal run your app:
 go run app.go
 ```
 
-## [Docs](https://labstack.com/docs/api) | [Forum](https://forum.labstack.com)
+## [Docs](https://labstack.com/docs) | [Forum](https://forum.labstack.com)

README.md

@@ -0,0 +1,220 @@
+package cube
+
+import (
+	"os"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/go-resty/resty"
+	"github.com/labstack/gommon/log"
+	"github.com/shirou/gopsutil/process"
+)
+
+type (
+	Cube struct {
+		Options
+		startTime      int64
+		uptime         int64
+		cpu            float32
+		memory         uint64
+		requests       []*Request
+		activeRequests int64
+		mutex          sync.RWMutex
+		client         *resty.Client
+		logger         *log.Logger
+	}
+
+	Options struct {
+		// Node id
+		Node string
+
+		// Tags
+		Tags []string
+
+		// Number of requests in a batch
+		BatchSize int
+
+		// Interval in seconds to dispatch the batch
+		DispatchInterval time.Duration
+	}
+
+	Request struct {
+		ID         string   `json:"id,omitempty"`
+		Time       int64    `json:"time,omitempty"`
+		Tags       []string `json:"tags,omitempty"`
+		Host       string   `json:"host,omitempty"`
+		Path       string   `json:"path,omitempty"`
+		Method     string   `json:"method,omitempty"`
+		Status     int      `json:"status,omitempty"`
+		BytesIn    int64    `json:"bytes_in,omitempty"`
+		BytesOut   int64    `json:"bytes_out,omitempty"`
+		Latency    int64    `json:"latency,omitempty"`
+		ClientID   string   `json:"client_id,omitempty"`
+		RemoteIP   string   `json:"remote_ip,omitempty"`
+		UserAgent  string   `json:"user_agent,omitempty"`
+		Active     int64    `json:"active,omitempty"`
+		Error      string   `json:"error,omitempty"`
+		StackTrace string   `json:"stack_trace,omitempty"`
+		Node       string   `json:"node,omitempty"`
+		Uptime     int64    `json:"uptime,omitempty"`
+		CPU        float32  `json:"cpu,omitempty"`
+		Memory     uint64   `json:"memory,omitempty"`
+	}
+
+	// APIError struct {
+	// 	Code    int    `json:"code"`
+	// 	Message string `json:"message"`
+	// }
+)
+
+func New(apiKey string, options Options) *Cube {
+	c := &Cube{
+		startTime: time.Now().Unix(),
+		client: resty.New().
+			SetHostURL("https://api.labstack.com").
+			SetAuthToken(apiKey).
+			SetHeader("User-Agent", "labstack/cube"),
+		logger: log.New("cube"),
+	}
+	c.Options = options
+
+	// Defaults
+	if c.Node == "" {
+		c.Node, _ = os.Hostname()
+	}
+	if c.BatchSize == 0 {
+		c.BatchSize = 60
+	}
+	if c.DispatchInterval == 0 {
+		c.DispatchInterval = 60
+	}
+
+	// Dispatch daemon
+	go func() {
+		d := time.Duration(c.DispatchInterval) * time.Second
+		for range time.Tick(d) {
+			c.Dispatch()
+		}
+	}()
+
+	// System daemon
+	go func() {
+		p, _ := process.NewProcess(int32(os.Getpid()))
+
+		for range time.Tick(time.Second) {
+			c.uptime = time.Now().Unix() - c.startTime
+			cpu, _ := p.CPUPercent()
+			c.cpu = float32(cpu)
+			mem, _ := p.MemoryInfo()
+			c.memory = mem.RSS
+		}
+	}()
+
+	return c
+}
+
+func (c *Cube) resetRequests() {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+	c.requests = make([]*Request, 0, c.BatchSize)
+}
+
+func (c *Cube) appendRequest(r *Request) {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+	c.requests = append(c.requests, r)
+}
+
+func (c *Cube) listRequests() []*Request {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+	requests := make([]*Request, len(c.requests))
+	for i, r := range c.requests {
+		requests[i] = r
+	}
+	return requests
+}
+
+func (c *Cube) requestsLength() int {
+	c.mutex.RLock()
+	defer c.mutex.RUnlock()
+	return len(c.requests)
+}
+
+// Dispatch dispatches the requests batch.
+func (c *Cube) Dispatch() {
+	if len(c.requests) == 0 {
+		return
+	}
+
+	// err := new(APIError)
+	res, err := c.client.R().
+		SetBody(c.listRequests()).
+		// SetError(err).
+		Post("/cube")
+	if err != nil {
+		c.logger.Error(err)
+		return
+	}
+	if res.StatusCode() < 200 || res.StatusCode() >= 300 {
+		c.logger.Error(res.Body())
+	}
+
+	c.resetRequests()
+}
+
+// Start starts cording an HTTP request.
+func (c *Cube) Start(r *Request) {
+	atomic.AddInt64(&c.activeRequests, 1)
+
+	r.Time = time.Now().UnixNano() / 1000
+	r.Active = c.activeRequests
+	r.Node = c.Node
+	r.Uptime = c.uptime
+	r.CPU = c.cpu
+	r.Memory = c.memory
+	r.Tags = c.Tags
+
+	c.appendRequest(r)
+}
+
+// Stop stops recording an HTTP request.
+func (c *Cube) Stop(r *Request) {
+	atomic.AddInt64(&c.activeRequests, -1)
+
+	r.Latency = time.Now().UnixNano()/1000 - r.Time
+
+	// Dispatch batch
+	if c.requestsLength() >= c.BatchSize {
+		go func() {
+			c.Dispatch()
+		}()
+	}
+}
+
+// RequestID returns the request ID from the request or response.
+// func RequestID(r *http.Request, w http.ResponseWriter) string {
+// 	id := r.Header.Get("X-Request-ID")
+// 	if id == "" {
+// 		id = w.Header().Get("X-Request-ID")
+// 	}
+// 	return id
+// }
+
+// RealIP returns the real IP from the request.
+// func RealIP(r *http.Request) string {
+// 	ra := r.RemoteAddr
+// 	if ip := r.Header.Get("X-Forwarded-For"); ip != "" {
+// 		ra = strings.Split(ip, ", ")[0]
+// 	} else if ip := r.Header.Get("X-Real-IP"); ip != "" {
+// 		ra = ip
+// 	} else {
+// 		ra, _, _ = net.SplitHostPort(ra)
+// 	}
+// 	return ra
+// }
+
+// func (e *APIError) Error() string {
+// 	return e.Message
+// }

cube/cube.go

@@ -0,0 +1,52 @@
+package echo
+
+import (
+	"strconv"
+
+	"github.com/labstack/echo"
+	"github.com/labstack/labstack-go/cube"
+	"github.com/labstack/labstack-go/util"
+)
+
+func Cube(apiKey string) echo.MiddlewareFunc {
+	return CubeWithOptions(apiKey, cube.Options{})
+}
+
+func CubeWithOptions(apiKey string, options cube.Options) echo.MiddlewareFunc {
+	c := cube.New(apiKey, options)
+
+	return func(next echo.HandlerFunc) echo.HandlerFunc {
+		return func(ctx echo.Context) (err error) {
+			// Start
+			req := ctx.Request()
+			res := ctx.Response()
+			bytesIn, err := strconv.ParseInt(req.Header.Get("Content-Length"), 10, 64)
+			r := &cube.Request{
+				ID:        req.Header.Get(echo.HeaderXRequestID),
+				Host:      util.StripPort(req.Host),
+				Path:      req.URL.Path,
+				Method:    req.Method,
+				BytesIn:   bytesIn,
+				RemoteIP:  ctx.RealIP(),
+				ClientID:  req.Header.Get("X-Client-ID"),
+				UserAgent: req.UserAgent(),
+			}
+			c.Start(r)
+
+			// Next
+			if err = next(ctx); err != nil {
+				ctx.Error(err)
+			}
+
+			// Stop
+			if r.ID == "" {
+				r.ID = res.Header().Get(echo.HeaderXRequestID)
+			}
+			r.Status = res.Status
+			r.BytesOut = res.Size
+			c.Stop(r)
+
+			return nil
+		}
+	}
+}

cube/echo/echo.go

@@ -0,0 +1,16 @@
+package util
+
+import "strings"
+
+// StripPort strips port from the host.
+// https://golang.org/pkg/net/url/#URL.Hostname
+func StripPort(host string) string {
+	colon := strings.IndexByte(host, ':')
+	if colon == -1 {
+		return host
+	}
+	if i := strings.IndexByte(host, ']'); i != -1 {
+		return strings.TrimPrefix(host[:i], "[")
+	}
+	return host[:colon]
+}