elasticsearch: new simple client for communicating with elasticsearch

Handles minor differences of es 2, 5 and 5.6.
Implements index pattern logic.
Exposes builders for building search requests.

pkg/tsdb/elasticsearch/client/client.go

+package es
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"path"
+	"strings"
+	"time"
+
+	"github.com/grafana/grafana/pkg/components/simplejson"
+	"github.com/grafana/grafana/pkg/log"
+	"github.com/grafana/grafana/pkg/tsdb"
+
+	"github.com/grafana/grafana/pkg/models"
+	"golang.org/x/net/context/ctxhttp"
+)
+
+const loggerName = "tsdb.elasticsearch.client"
+
+var (
+	clientLog          = log.New(loggerName)
+	intervalCalculator = tsdb.NewIntervalCalculator(&tsdb.IntervalOptions{MinInterval: 15 * time.Second})
+)
+
+// Client represents a client which can interact with elasticsearch api
+type Client interface {
+	GetVersion() int
+	GetTimeField() string
+	GetMinInterval(queryInterval string) (time.Duration, error)
+	ExecuteMultisearch(r *MultiSearchRequest) (*MultiSearchResponse, error)
+	MultiSearch() *MultiSearchRequestBuilder
+}
+
+// NewClient creates a new elasticsearch client
+var NewClient = func(ctx context.Context, ds *models.DataSource, timeRange *tsdb.TimeRange) (Client, error) {
+	version, err := ds.JsonData.Get("esVersion").Int()
+	if err != nil {
+		return nil, fmt.Errorf("eleasticsearch version is required, err=%v", err)
+	}
+
+	timeField, err := ds.JsonData.Get("timeField").String()
+	if err != nil {
+		return nil, fmt.Errorf("eleasticsearch time field name is required, err=%v", err)
+	}
+
+	indexInterval := ds.JsonData.Get("interval").MustString()
+	ip, err := newIndexPattern(indexInterval, ds.Database)
+	if err != nil {
+		return nil, err
+	}
+
+	indices, err := ip.GetIndices(timeRange)
+	if err != nil {
+		return nil, err
+	}
+
+	bc := &baseClientImpl{
+		ctx:       ctx,
+		ds:        ds,
+		version:   version,
+		timeField: timeField,
+		indices:   indices,
+	}
+
+	clientLog.Debug("Creating new client", "version", version, "timeField", timeField, "indices", strings.Join(indices, ", "))
+
+	switch version {
+	case 2:
+		return newV2Client(bc)
+	case 5:
+		return newV5Client(bc)
+	case 56:
+		return newV56Client(bc)
+	}
+
+	return nil, fmt.Errorf("elasticsearch version=%d is not supported", version)
+}
+
+type baseClient interface {
+	Client
+	getSettings() *simplejson.Json
+	executeBatchRequest(uriPath string, requests []*multiRequest) (*http.Response, error)
+	executeRequest(method, uriPath string, body []byte) (*http.Response, error)
+	createMultiSearchRequests(searchRequests []*SearchRequest) []*multiRequest
+}
+
+type baseClientImpl struct {
+	ctx       context.Context
+	ds        *models.DataSource
+	version   int
+	timeField string
+	indices   []string
+}
+
+func (c *baseClientImpl) GetVersion() int {
+	return c.version
+}
+
+func (c *baseClientImpl) GetTimeField() string {
+	return c.timeField
+}
+
+func (c *baseClientImpl) GetMinInterval(queryInterval string) (time.Duration, error) {
+	return tsdb.GetIntervalFrom(c.ds, simplejson.NewFromAny(map[string]string{
+		"interval": queryInterval,
+	}), 15*time.Second)
+}
+
+func (c *baseClientImpl) getSettings() *simplejson.Json {
+	return c.ds.JsonData
+}
+
+type multiRequest struct {
+	header map[string]interface{}
+	body   interface{}
+}
+
+func (c *baseClientImpl) executeBatchRequest(uriPath string, requests []*multiRequest) (*http.Response, error) {
+	payload := bytes.Buffer{}
+	for _, r := range requests {
+		reqHeader, err := json.Marshal(r.header)
+		if err != nil {
+			return nil, err
+		}
+		payload.WriteString(string(reqHeader) + "\n")
+
+		reqBody, err := json.Marshal(r.body)
+		if err != nil {
+			return nil, err
+		}
+		payload.WriteString(string(reqBody) + "\n")
+	}
+
+	return c.executeRequest(http.MethodPost, uriPath, payload.Bytes())
+}
+
+func (c *baseClientImpl) executeRequest(method, uriPath string, body []byte) (*http.Response, error) {
+	u, _ := url.Parse(c.ds.Url)
+	u.Path = path.Join(u.Path, uriPath)
+
+	var req *http.Request
+	var err error
+	if method == http.MethodPost {
+		req, err = http.NewRequest(http.MethodPost, u.String(), bytes.NewBuffer(body))
+	} else {
+		req, err = http.NewRequest(http.MethodGet, u.String(), nil)
+	}
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("User-Agent", "Grafana")
+	req.Header.Set("Content-Type", "application/json")
+
+	if c.ds.BasicAuth {
+		clientLog.Debug("Request configured to use basic authentication")
+		req.SetBasicAuth(c.ds.BasicAuthUser, c.ds.BasicAuthPassword)
+	}
+
+	if !c.ds.BasicAuth && c.ds.User != "" {
+		clientLog.Debug("Request configured to use basic authentication")
+		req.SetBasicAuth(c.ds.User, c.ds.Password)
+	}
+
+	httpClient, err := c.ds.GetHttpClient()
+	if err != nil {
+		return nil, err
+	}
+
+	if method == http.MethodPost {
+		clientLog.Debug("Executing request", "url", req.URL.String(), "method", method)
+	} else {
+		clientLog.Debug("Executing request", "url", req.URL.String(), "method", method)
+	}
+
+	return ctxhttp.Do(c.ctx, httpClient, req)
+}
+
+func (c *baseClientImpl) ExecuteMultisearch(r *MultiSearchRequest) (*MultiSearchResponse, error) {
+	multiRequests := c.createMultiSearchRequests(r.Requests)
+	res, err := c.executeBatchRequest("_msearch", multiRequests)
+	if err != nil {
+		return nil, err
+	}
+
+	var msr MultiSearchResponse
+	defer res.Body.Close()
+	dec := json.NewDecoder(res.Body)
+	err = dec.Decode(&msr)
+	if err != nil {
+		return nil, err
+	}
+
+	clientLog.Debug("Received multisearch response", "code", res.StatusCode, "status", res.Status, "content-length", res.ContentLength)
+
+	msr.status = res.StatusCode
+
+	return &msr, nil
+}
+
+func (c *baseClientImpl) createMultiSearchRequests(searchRequests []*SearchRequest) []*multiRequest {
+	multiRequests := []*multiRequest{}
+
+	for _, searchReq := range searchRequests {
+		multiRequests = append(multiRequests, &multiRequest{
+			header: map[string]interface{}{
+				"search_type":        "query_then_fetch",
+				"ignore_unavailable": true,
+				"index":              strings.Join(c.indices, ","),
+			},
+			body: searchReq,
+		})
+	}
+
+	return multiRequests
+}
+
+type v2Client struct {
+	baseClient
+}
+
+func newV2Client(bc baseClient) (*v2Client, error) {
+	c := v2Client{
+		baseClient: bc,
+	}
+
+	return &c, nil
+}
+
+func (c *v2Client) createMultiSearchRequests(searchRequests []*SearchRequest) []*multiRequest {
+	multiRequests := c.baseClient.createMultiSearchRequests(searchRequests)
+
+	for _, mr := range multiRequests {
+		mr.header["search_type"] = "count"
+	}
+
+	return multiRequests
+}
+
+type v5Client struct {
+	baseClient
+}
+
+func newV5Client(bc baseClient) (*v5Client, error) {
+	c := v5Client{
+		baseClient: bc,
+	}
+
+	return &c, nil
+}
+
+type v56Client struct {
+	*v5Client
+	maxConcurrentShardRequests int
+}
+
+func newV56Client(bc baseClient) (*v56Client, error) {
+	v5Client := v5Client{
+		baseClient: bc,
+	}
+	maxConcurrentShardRequests := bc.getSettings().Get("maxConcurrentShardRequests").MustInt(256)
+
+	c := v56Client{
+		v5Client:                   &v5Client,
+		maxConcurrentShardRequests: maxConcurrentShardRequests,
+	}
+
+	return &c, nil
+}
+
+func (c *v56Client) createMultiSearchRequests(searchRequests []*SearchRequest) []*multiRequest {
+	multiRequests := c.v5Client.createMultiSearchRequests(searchRequests)
+
+	for _, mr := range multiRequests {
+		mr.header["max_concurrent_shard_requests"] = c.maxConcurrentShardRequests
+	}
+
+	return multiRequests
+}
+
+func (c *baseClientImpl) MultiSearch() *MultiSearchRequestBuilder {
+	return NewMultiSearchRequestBuilder(c.GetVersion())
+}

pkg/tsdb/elasticsearch/client/client_test.go

+package es
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/grafana/grafana/pkg/components/simplejson"
+
+	"github.com/grafana/grafana/pkg/models"
+	. "github.com/smartystreets/goconvey/convey"
+)
+
+func TestClient(t *testing.T) {
+	Convey("Test elasticsearch client", t, func() {
+		Convey("NewClient", func() {
+			Convey("When no version set should return error", func() {
+				ds := &models.DataSource{
+					JsonData: simplejson.NewFromAny(make(map[string]interface{})),
+				}
+
+				_, err := NewClient(nil, ds, nil)
+				So(err, ShouldNotBeNil)
+			})
+
+			Convey("When no time field name set should return error", func() {
+				ds := &models.DataSource{
+					JsonData: simplejson.NewFromAny(map[string]interface{}{
+						"esVersion": 5,
+					}),
+				}
+
+				_, err := NewClient(nil, ds, nil)
+				So(err, ShouldNotBeNil)
+			})
+
+			Convey("When unspported version set should return error", func() {
+				ds := &models.DataSource{
+					JsonData: simplejson.NewFromAny(map[string]interface{}{
+						"esVersion": 6,
+						"timeField": "@timestamp",
+					}),
+				}
+
+				_, err := NewClient(nil, ds, nil)
+				So(err, ShouldNotBeNil)
+			})
+
+			Convey("When version 2 should return v2 client", func() {
+				ds := &models.DataSource{
+					JsonData: simplejson.NewFromAny(map[string]interface{}{
+						"esVersion": 2,
+						"timeField": "@timestamp",
+					}),
+				}
+
+				c, err := NewClient(nil, ds, nil)
+				So(err, ShouldBeNil)
+				So(c.GetVersion(), ShouldEqual, 2)
+			})
+
+			Convey("When version 5 should return v5 client", func() {
+				ds := &models.DataSource{
+					JsonData: simplejson.NewFromAny(map[string]interface{}{
+						"esVersion": 5,
+						"timeField": "@timestamp",
+					}),
+				}
+
+				c, err := NewClient(nil, ds, nil)
+				So(err, ShouldBeNil)
+				So(c.GetVersion(), ShouldEqual, 5)
+			})
+
+			Convey("When version 56 should return v5.6 client", func() {
+				ds := &models.DataSource{
+					JsonData: simplejson.NewFromAny(map[string]interface{}{
+						"esVersion": 56,
+						"timeField": "@timestamp",
+					}),
+				}
+
+				c, err := NewClient(nil, ds, nil)
+				So(err, ShouldBeNil)
+				So(c.GetVersion(), ShouldEqual, 56)
+			})
+		})
+
+		Convey("v2", func() {
+			ds := &models.DataSource{
+				JsonData: simplejson.NewFromAny(map[string]interface{}{
+					"esVersion": 2,
+				}),
+			}
+
+			c, err := newV2Client(newFakeBaseClient(ds, []string{"test-*"}))
+			So(err, ShouldBeNil)
+			So(c, ShouldNotBeNil)
+
+			Convey("When creating multisearch requests should have correct headers", func() {
+				multiRequests := c.createMultiSearchRequests([]*SearchRequest{
+					{Index: "test-*"},
+				})
+				So(multiRequests, ShouldHaveLength, 1)
+				header := multiRequests[0].header
+				So(header, ShouldHaveLength, 3)
+				So(header["index"], ShouldEqual, "test-*")
+				So(header["ignore_unavailable"], ShouldEqual, true)
+				So(header["search_type"], ShouldEqual, "count")
+			})
+		})
+
+		Convey("v5", func() {
+			ds := &models.DataSource{
+				JsonData: simplejson.NewFromAny(map[string]interface{}{
+					"esVersion": 5,
+				}),
+			}
+
+			c, err := newV5Client(newFakeBaseClient(ds, []string{"test-*"}))
+			So(err, ShouldBeNil)
+			So(c, ShouldNotBeNil)
+
+			Convey("When creating multisearch requests should have correct headers", func() {
+				multiRequests := c.createMultiSearchRequests([]*SearchRequest{
+					{Index: "test-*"},
+				})
+				So(multiRequests, ShouldHaveLength, 1)
+				header := multiRequests[0].header
+				So(header, ShouldHaveLength, 3)
+				So(header["index"], ShouldEqual, "test-*")
+				So(header["ignore_unavailable"], ShouldEqual, true)
+				So(header["search_type"], ShouldEqual, "query_then_fetch")
+			})
+		})
+
+		Convey("v5.6", func() {
+			Convey("With default settings", func() {
+				ds := models.DataSource{
+					JsonData: simplejson.NewFromAny(map[string]interface{}{
+						"esVersion": 56,
+					}),
+				}
+
+				c, err := newV56Client(newFakeBaseClient(&ds, []string{"test-*"}))
+				So(err, ShouldBeNil)
+				So(c, ShouldNotBeNil)
+
+				Convey("When creating multisearch requests should have correct headers", func() {
+					multiRequests := c.createMultiSearchRequests([]*SearchRequest{
+						{Index: "test-*"},
+					})
+					So(multiRequests, ShouldHaveLength, 1)
+					header := multiRequests[0].header
+					So(header, ShouldHaveLength, 4)
+					So(header["index"], ShouldEqual, "test-*")
+					So(header["ignore_unavailable"], ShouldEqual, true)
+					So(header["search_type"], ShouldEqual, "query_then_fetch")
+					So(header["max_concurrent_shard_requests"], ShouldEqual, 256)
+				})
+			})
+
+			Convey("With custom settings", func() {
+				ds := models.DataSource{
+					JsonData: simplejson.NewFromAny(map[string]interface{}{
+						"esVersion":                  56,
+						"maxConcurrentShardRequests": 100,
+					}),
+				}
+
+				c, err := newV56Client(newFakeBaseClient(&ds, []string{"test-*"}))
+				So(err, ShouldBeNil)
+				So(c, ShouldNotBeNil)
+				Convey("When creating multisearch requests should have correct headers", func() {
+					multiRequests := c.createMultiSearchRequests([]*SearchRequest{
+						{Index: "test-*"},
+					})
+					So(multiRequests, ShouldHaveLength, 1)
+					header := multiRequests[0].header
+					So(header, ShouldHaveLength, 4)
+					So(header["index"], ShouldEqual, "test-*")
+					So(header["ignore_unavailable"], ShouldEqual, true)
+					So(header["search_type"], ShouldEqual, "query_then_fetch")
+					So(header["max_concurrent_shard_requests"], ShouldEqual, 100)
+				})
+			})
+		})
+	})
+}
+
+type fakeBaseClient struct {
+	*baseClientImpl
+	ds *models.DataSource
+}
+
+func newFakeBaseClient(ds *models.DataSource, indices []string) baseClient {
+	return &fakeBaseClient{
+		baseClientImpl: &baseClientImpl{
+			ds:      ds,
+			indices: indices,
+		},
+		ds: ds,
+	}
+}
+
+func (c *fakeBaseClient) executeBatchRequest(uriPath string, requests []*multiRequest) (*http.Response, error) {
+	return nil, nil
+}
+
+func (c *fakeBaseClient) executeRequest(method, uriPath string, body []byte) (*http.Response, error) {
+	return nil, nil
+}
+
+func (c *fakeBaseClient) executeMultisearch(searchRequests []*SearchRequest) ([]*SearchResponse, error) {
+	return nil, nil
+}

pkg/tsdb/elasticsearch/client/models.go

+package es
+
+import (
+	"encoding/json"
+)
+
+// SearchRequest represents a search request
+type SearchRequest struct {
+	Index       string
+	Size        int
+	Sort        map[string]interface{}
+	Query       *Query
+	Aggs        AggArray
+	CustomProps map[string]interface{}
+}
+
+// MarshalJSON returns the JSON encoding of the request.
+func (r *SearchRequest) MarshalJSON() ([]byte, error) {
+	root := make(map[string]interface{})
+
+	root["size"] = r.Size
+	if len(r.Sort) > 0 {
+		root["sort"] = r.Sort
+	}
+
+	for key, value := range r.CustomProps {
+		root[key] = value
+	}
+
+	root["query"] = r.Query
+
+	if len(r.Aggs) > 0 {
+		root["aggs"] = r.Aggs
+	}
+
+	return json.Marshal(root)
+}
+
+// SearchResponseHits represents search response hits
+type SearchResponseHits struct {
+	Hits  []map[string]interface{}
+	Total int64
+}
+
+// SearchResponse represents a search response
+type SearchResponse struct {
+	Error        map[string]interface{} `json:"error"`
+	Aggregations map[string]interface{} `json:"aggregations"`
+	Hits         *SearchResponseHits    `json:"hits"`
+}
+
+// func (r *Response) getErrMsg() string {
+// 	var msg bytes.Buffer
+// 	errJson := simplejson.NewFromAny(r.Err)
+// 	errType, err := errJson.Get("type").String()
+// 	if err == nil {
+// 		msg.WriteString(fmt.Sprintf("type:%s", errType))
+// 	}
+
+// 	reason, err := errJson.Get("type").String()
+// 	if err == nil {
+// 		msg.WriteString(fmt.Sprintf("reason:%s", reason))
+// 	}
+// 	return msg.String()
+// }
+
+// MultiSearchRequest represents a multi search request
+type MultiSearchRequest struct {
+	Requests []*SearchRequest
+}
+
+// MultiSearchResponse represents a multi search response
+type MultiSearchResponse struct {
+	status    int               `json:"status,omitempty"`
+	Responses []*SearchResponse `json:"responses"`
+}
+
+// Query represents a query
+type Query struct {
+	Bool *BoolQuery `json:"bool"`
+}
+
+// BoolQuery represents a bool query
+type BoolQuery struct {
+	Filters []Filter
+}
+
+// NewBoolQuery create a new bool query
+func NewBoolQuery() *BoolQuery {
+	return &BoolQuery{Filters: make([]Filter, 0)}
+}
+
+// MarshalJSON returns the JSON encoding of the boolean query.
+func (q *BoolQuery) MarshalJSON() ([]byte, error) {
+	root := make(map[string]interface{})
+
+	if len(q.Filters) > 0 {
+		if len(q.Filters) == 1 {
+			root["filter"] = q.Filters[0]
+		} else {
+			root["filter"] = q.Filters
+		}
+	}
+	return json.Marshal(root)
+}
+
+// Filter represents a search filter
+type Filter interface{}
+
+// QueryStringFilter represents a query string search filter
+type QueryStringFilter struct {
+	Filter
+	Query           string
+	AnalyzeWildcard bool
+}
+
+// MarshalJSON returns the JSON encoding of the query string filter.
+func (f *QueryStringFilter) MarshalJSON() ([]byte, error) {
+	root := map[string]interface{}{
+		"query_string": map[string]interface{}{
+			"query":            f.Query,
+			"analyze_wildcard": f.AnalyzeWildcard,
+		},
+	}
+
+	return json.Marshal(root)
+}
+
+// RangeFilter represents a range search filter
+type RangeFilter struct {
+	Filter
+	Key    string
+	Gte    string
+	Lte    string
+	Format string
+}
+
+// DateFormatEpochMS represents a date format of epoch milliseconds (epoch_millis)
+const DateFormatEpochMS = "epoch_millis"
+
+// MarshalJSON returns the JSON encoding of the query string filter.
+func (f *RangeFilter) MarshalJSON() ([]byte, error) {
+	root := map[string]map[string]map[string]interface{}{
+		"range": {
+			f.Key: {
+				"lte": f.Lte,
+				"gte": f.Gte,
+			},
+		},
+	}
+
+	if f.Format != "" {
+		root["range"][f.Key]["format"] = f.Format
+	}
+
+	return json.Marshal(root)
+}
+
+// Aggregation represents an aggregation
+type Aggregation interface{}
+
+// Agg represents a key and aggregation
+type Agg struct {
+	Key         string
+	Aggregation *aggContainer
+}
+
+// MarshalJSON returns the JSON encoding of the agg
+func (a *Agg) MarshalJSON() ([]byte, error) {
+	root := map[string]interface{}{
+		a.Key: a.Aggregation,
+	}
+
+	return json.Marshal(root)
+}
+
+// AggArray represents a collection of key/aggregation pairs
+type AggArray []*Agg
+
+// MarshalJSON returns the JSON encoding of the agg
+func (a AggArray) MarshalJSON() ([]byte, error) {
+	aggsMap := make(map[string]Aggregation)
+
+	for _, subAgg := range a {
+		aggsMap[subAgg.Key] = subAgg.Aggregation
+	}
+
+	return json.Marshal(aggsMap)
+}
+
+type aggContainer struct {
+	Type        string
+	Aggregation Aggregation
+	Aggs        AggArray
+}
+
+// MarshalJSON returns the JSON encoding of the aggregation container
+func (a *aggContainer) MarshalJSON() ([]byte, error) {
+	root := map[string]interface{}{
+		a.Type: a.Aggregation,
+	}
+
+	if len(a.Aggs) > 0 {
+		root["aggs"] = a.Aggs
+	}
+
+	return json.Marshal(root)
+}
+
+type aggDef struct {
+	key         string
+	aggregation *aggContainer
+	builders    []AggBuilder
+}
+
+func newAggDef(key string, aggregation *aggContainer) *aggDef {
+	return &aggDef{
+		key:         key,
+		aggregation: aggregation,
+		builders:    make([]AggBuilder, 0),
+	}
+}
+
+// HistogramAgg represents a histogram aggregation
+type HistogramAgg struct {
+	Interval    int    `json:"interval,omitempty"`
+	Field       string `json:"field"`
+	MinDocCount int    `json:"min_doc_count"`
+	Missing     *int   `json:"missing,omitempty"`
+}
+
+// DateHistogramAgg represents a date histogram aggregation
+type DateHistogramAgg struct {
+	Field          string          `json:"field"`
+	Interval       string          `json:"interval,omitempty"`
+	MinDocCount    int             `json:"min_doc_count"`
+	Missing        *string         `json:"missing,omitempty"`
+	ExtendedBounds *ExtendedBounds `json:"extended_bounds"`
+	Format         string          `json:"format"`
+}
+
+// FiltersAggregation represents a filters aggregation
+type FiltersAggregation struct {
+	Filters map[string]interface{} `json:"filters"`
+}
+
+// TermsAggregation represents a terms aggregation
+type TermsAggregation struct {
+	Field       string                 `json:"field"`
+	Size        int                    `json:"size"`
+	Order       map[string]interface{} `json:"order"`
+	MinDocCount *int                   `json:"min_doc_count,omitempty"`
+	Missing     *string                `json:"missing,omitempty"`
+}
+
+// ExtendedBounds represents extended bounds
+type ExtendedBounds struct {
+	Min string `json:"min"`
+	Max string `json:"max"`
+}
+
+// GeoHashGridAggregation represents a geo hash grid aggregation
+type GeoHashGridAggregation struct {
+	Field     string `json:"field"`
+	Precision int    `json:"precision"`
+}
+
+// MetricAggregation represents a metric aggregation
+type MetricAggregation struct {
+	Field    string
+	Settings map[string]interface{}
+}
+
+// MarshalJSON returns the JSON encoding of the metric aggregation
+func (a *MetricAggregation) MarshalJSON() ([]byte, error) {
+	root := map[string]interface{}{
+		"field": a.Field,
+	}
+
+	for k, v := range a.Settings {
+		root[k] = v
+	}
+
+	return json.Marshal(root)
+}
+
+// PipelineAggregation represents a metric aggregation
+type PipelineAggregation struct {
+	BucketPath string
+	Settings   map[string]interface{}
+}
+
+// MarshalJSON returns the JSON encoding of the pipeline aggregation
+func (a *PipelineAggregation) MarshalJSON() ([]byte, error) {
+	root := map[string]interface{}{
+		"bucket_path": a.BucketPath,
+	}
+
+	for k, v := range a.Settings {
+		root[k] = v
+	}
+
+	return json.Marshal(root)
+}