Per new api

Author: vishr

client.go

@@ -14,6 +14,17 @@ type (
 		AppID   string
 		AppName string
 	}
+
+	Fields map[string]interface{}
+
+	SearchParameters struct {
+		Query       string   `json:"query"`
+		QueryString string   `json:"query_string"`
+		Since       string   `json:"since"`
+		Sort        []string `json:"sort"`
+		Size        int      `json:"size"`
+		From        int      `json:"from"`
+	}
 )
 
 const (
@@ -67,7 +78,7 @@ func (c *Client) Log() (log *Log) {
 		BatchSize:        60,
 		DispatchInterval: 60,
 	}
-	log.resetLogEntries()
+	log.resetEntries()
 	return
 }
 
@@ -78,3 +89,12 @@ func (c *Client) Store() *Store {
 		logger: c.logger,
 	}
 }
+
+func (f Fields) Add(key string, value interface{}) Fields {
+	f[key] = value
+	return f
+}
+
+func (f Fields) Get(key string) interface{} {
+	return f[key]
+}

log.go

@@ -13,13 +13,12 @@ type (
 	// Log defines the LabStack log service.
 	Log struct {
 		sling            *sling.Sling
-		logs             []*logEntry
+		entries          []Fields
 		timer            <-chan time.Time
 		mutex            sync.RWMutex
 		logger           *glog.Logger
 		AppID            string
 		AppName          string
-		Tags             []string
 		Level            Level
 		BatchSize        int
 		DispatchInterval int
@@ -28,16 +27,6 @@ type (
 	// Level defines the log level.
 	Level int
 
-	// logEntry defines a log entry.
-	logEntry struct {
-		Time    string   `json:"time"`
-		AppID   string   `json:"app_id"`
-		AppName string   `json:"app_name"`
-		Tags    []string `json:"tags"`
-		Level   string   `json:"level"`
-		Message string   `json:"message"`
-	}
-
 	// LogError defines the log error.
 	LogError struct {
 		Code    int    `json:"code"`
@@ -63,43 +52,43 @@ var levels = map[Level]string{
 	LevelFatal: "FATAL",
 }
 
-func (l *Log) resetLogEntries() {
+func (l *Log) resetEntries() {
 	l.mutex.Lock()
 	defer l.mutex.Unlock()
-	l.logs = make([]*logEntry, 0, l.BatchSize)
+	l.entries = make([]Fields, 0, l.BatchSize)
 }
 
-func (l *Log) appendLogEntry(lm *logEntry) {
+func (l *Log) appendEntry(f Fields) {
 	l.mutex.Lock()
 	defer l.mutex.Unlock()
-	l.logs = append(l.logs, lm)
+	l.entries = append(l.entries, f)
 }
 
-func (l *Log) listLogEntries() []*logEntry {
+func (l *Log) listEntries() []Fields {
 	l.mutex.Lock()
 	defer l.mutex.Unlock()
-	logs := make([]*logEntry, len(l.logs))
-	for i, log := range l.logs {
-		logs[i] = log
+	entries := make([]Fields, len(l.entries))
+	for i, entry := range l.entries {
+		entries[i] = entry
 	}
-	return logs
+	return entries
 }
 
 func (l *Log) logsLength() int {
 	l.mutex.RLock()
 	defer l.mutex.RUnlock()
-	return len(l.logs)
+	return len(l.entries)
 }
 
 func (l *Log) dispatch() error {
-	if len(l.logs) == 0 {
+	if len(l.entries) == 0 {
 		return nil
 	}
 
-	defer l.resetLogEntries()
+	defer l.resetEntries()
 
 	le := new(LogError)
-	_, err := l.sling.Post("").BodyJSON(l.listLogEntries()).Receive(nil, le)
+	_, err := l.sling.Post("").BodyJSON(l.listEntries()).Receive(nil, le)
 	if err != nil {
 		return err
 	}
@@ -110,32 +99,32 @@ func (l *Log) dispatch() error {
 }
 
 // Debug logs a message with DEBUG level.
-func (l *Log) Debug(format string, args ...interface{}) {
-	l.Log(LevelDebug, format, args...)
+func (l *Log) Debug(fields Fields) {
+	l.Log(LevelDebug, fields)
 }
 
 // Info logs a message with INFO level.
-func (l *Log) Info(format string, args ...interface{}) {
-	l.Log(LevelInfo, format, args...)
+func (l *Log) Info(fields Fields) {
+	l.Log(LevelInfo, fields)
 }
 
 // Warn logs a message with WARN level.
-func (l *Log) Warn(format string, args ...interface{}) {
-	l.Log(LevelWarn, format, args...)
+func (l *Log) Warn(fields Fields) {
+	l.Log(LevelWarn, fields)
 }
 
 // Error logs a message with ERROR level.
-func (l *Log) Error(format string, args ...interface{}) {
-	l.Log(LevelError, format, args...)
+func (l *Log) Error(fields Fields) {
+	l.Log(LevelError, fields)
 }
 
 // Fatal logs a message with FATAL level.
-func (l *Log) Fatal(format string, args ...interface{}) {
-	l.Log(LevelFatal, format, args...)
+func (l *Log) Fatal(fields Fields) {
+	l.Log(LevelFatal, fields)
 }
 
 // Log logs a message with log level.
-func (l *Log) Log(level Level, format string, args ...interface{}) {
+func (l *Log) Log(level Level, fields Fields) {
 	if level < l.Level {
 		return
 	}
@@ -152,16 +141,11 @@ func (l *Log) Log(level Level, format string, args ...interface{}) {
 		}()
 	}
 
-	message := fmt.Sprintf(format, args...)
-	lm := &logEntry{
-		Time:    time.Now().Format(rfc3339Milli),
-		AppID:   l.AppID,
-		AppName: l.AppName,
-		Tags:    l.Tags,
-		Level:   levels[level],
-		Message: message,
-	}
-	l.appendLogEntry(lm)
+	fields.Add("time", time.Now().Format(rfc3339Milli)).
+		Add("app_id", l.AppID).
+		Add("app_name", l.AppName).
+		Add("level", levels[level])
+	l.appendEntry(fields)
 
 	// Dispatch batch
 	if l.logsLength() >= l.BatchSize {

store.go

@@ -1,7 +1,7 @@
 package labstack
 
 import (
-	"time"
+	"fmt"
 
 	"github.com/dghubble/sling"
 	"github.com/labstack/gommon/log"
@@ -14,25 +14,12 @@ type (
 		logger *log.Logger
 	}
 
-	// StoreEntry defines the store entry
-	StoreEntry struct {
-		Key       string      `json:"key"`
-		Value     interface{} `json:"value"`
-		CreatedAt time.Time   `json:"created_at"`
-		UpdatedAt time.Time   `json:"updated_at"`
-	}
-
-	// storeQueryParams defines the query parameters for find entries.
-	storeQueryParams struct {
-		Filters string `url:"filters"`
-		Limit   int    `url:"limit"`
-		Offset  int    `url:"offset"`
-	}
+	Document Fields
 
-	// StoreQueryResponse defines the query response.
-	StoreQueryResponse struct {
-		Total   int64         `json:"total"`
-		Entries []*StoreEntry `json:"entries"`
+	// StoreSearchResponse defines the query response.
+	StoreSearchResponse struct {
+		Total     int64      `json:"total"`
+		Documents []Document `json:"documents"`
 	}
 
 	// StoreError defines the store error.
@@ -42,57 +29,54 @@ type (
 	}
 )
 
-func (s *Store) Insert(key string, value interface{}) (*StoreEntry, error) {
-	e := &StoreEntry{
-		Key:   key,
-		Value: value,
-	}
+func (s *Store) Insert(collection string, document Document) (Document, error) {
 	se := new(StoreError)
-	_, err := s.sling.Post("/store").BodyJSON(e).Receive(e, se)
+	_, err := s.sling.Post("/store/"+collection).
+		BodyJSON(&document).
+		Receive(&document, se)
 	if err != nil {
 		return nil, err
 	}
 	if se.Code == 0 {
-		return e, nil
+		return document, nil
 	}
 	return nil, se
 }
 
-func (s *Store) Get(key string) (*StoreEntry, error) {
-	e := new(StoreEntry)
+func (s *Store) Get(collection, id string) (Document, error) {
+	doc := Document{}
 	se := new(StoreError)
-	_, err := s.sling.Get("/store/"+key).Receive(e, se)
+	_, err := s.sling.Get(fmt.Sprintf("/store/%s/%s", collection, id)).
+		Receive(&doc, se)
 	if err != nil {
 		return nil, err
 	}
 	if se.Code == 0 {
-		return e, nil
+		return doc, nil
 	}
 	return nil, se
 }
 
-func (s *Store) Query(filters string, limit, offset int) (*StoreQueryResponse, error) {
-	qr := new(StoreQueryResponse)
+func (s *Store) Search(collection string, parameters *SearchParameters) (*StoreSearchResponse, error) {
+	sr := new(StoreSearchResponse)
 	se := new(StoreError)
-	_, err := s.sling.Get("/store").QueryStruct(&storeQueryParams{
-		Filters: filters,
-		Limit:   limit,
-		Offset:  offset,
-	}).Receive(qr, se)
+	_, err := s.sling.Post(fmt.Sprintf("/store/%s/query", collection)).
+		BodyJSON(parameters).
+		Receive(sr, se)
 	if err != nil {
 		return nil, err
 	}
 	if se.Code == 0 {
-		return qr, nil
+		return sr, nil
 	}
 	return nil, se
 }
 
-func (s *Store) Update(key string, value interface{}) error {
+func (s *Store) Update(collection string, id string, document Document) error {
 	se := new(StoreError)
-	_, err := s.sling.Put("/store/"+key).BodyJSON(&StoreEntry{
-		Value: value,
-	}).Receive(nil, se)
+	_, err := s.sling.Patch(fmt.Sprintf("/store/%s/%s", collection, id)).
+		BodyJSON(&document).
+		Receive(nil, se)
 	if err != nil {
 		return err
 	}
@@ -102,9 +86,10 @@ func (s *Store) Update(key string, value interface{}) error {
 	return se
 }
 
-func (s *Store) Delete(key string) error {
+func (s *Store) Delete(collection string, id string) error {
 	se := new(StoreError)
-	_, err := s.sling.Delete("/store/"+key).Receive(nil, se)
+	_, err := s.sling.Delete(fmt.Sprintf("/store/%s/%s", collection, id)).
+		Receive(nil, se)
 	if err != nil {
 		return err
 	}