Beispiel #1
0
func NewPerfDashApi(index string) *PerfDashApi {
	return &PerfDashApi{
		es:      elasticsearch.NewElasticsearch(),
		Index:   index,
		metrics: metrics.NewMetrics(),
	}
}
Beispiel #2
0
func InsertTestData(index string) error {

	es := elasticsearch.NewElasticsearch()

	gen := TestTransactionsGenerator{
		From:       time.Now().Add(-10 * time.Millisecond),
		To:         time.Now().Add(-1 * time.Microsecond),
		NrServices: 60,
		NrHosts:    10,
		RtMin:      0,
		RtMax:      1000,
		CountMin:   1,
		CountMax:   10,
		ErrorProb:  0.1,
	}
	transactions := gen.Generate()

	// make sure we start fresh
	_, err := es.DeleteIndex(index)
	if err != nil {
		return err
	}
	es.Refresh(index)

	err = InsertInto(es, index, transactions)
	if err != nil {
		return err
	}
	return nil
}
Beispiel #3
0
							"field":    "responsetime",
							"percents": []float32{50},
						},
					},
				}))
			})
		})
	})

	Context("With test ES", func() {
		var es *elasticsearch.Elasticsearch
		var index_name string
		var api *PerfDashApi
		BeforeEach(func() {
			index_name = fmt.Sprintf("packetbeat-unittest-%v", os.Getpid())
			es = elasticsearch.NewElasticsearch()

			_, err := es.DeleteIndex(index_name)
			Expect(err).To(BeNil())
			es.Refresh(index_name)

			ts1, _ := elasticsearch.TimeParse("2015-01-02T15:04:05.000Z")
			ts2, _ := elasticsearch.TimeParse("2015-01-02T15:04:05.001Z")

			transactions := []testdata.TestTransaction{
				testdata.TestTransaction{
					Timestamp:    ts1,
					Service:      "service1",
					Host:         "Host0",
					Count:        2,
					Responsetime: 2000,
Beispiel #4
0
func main() {
	to := time.Now()
	from := to.Add(-1 * time.Hour)

	samples := 100
	options := gengenOptionsForServices(samples, to, from)
	gen, err := testdata.NewGenGen(*options)
	if err != nil {
		fmt.Println(err)
		return
	}

	transChan := make(chan testdata.TestTransaction, 100)

	index_name := "packetbeat-test"
	es := elasticsearch.NewElasticsearch()

	// make sure we start fresh
	_, err = es.DeleteIndex(index_name)
	if err != nil {
		fmt.Println("Error: ", err)
		return
	}

	// create index with custom settings
	resp, err := es.Request("PUT", index_name, "", bytes.NewBufferString(
		`{"settings": {"index": {"refresh_interval": "-1"}}}`,
	))
	if err != nil {
		fmt.Println(elasticsearch.ResponseBody(resp))
		fmt.Println("Error: ", err)
		return
	}

	// generate in channel
	go func() {
		for i := 0; i < samples; i++ {
			for _, trans := range gen.Generate(i) {
				transChan <- testdata.TestTransaction{
					Timestamp:    elasticsearch.Time(trans["timestamp"].(time.Time)),
					Service:      trans["service"].(string),
					Host:         trans["host"].(string),
					Count:        int(trans["count"].(float64)),
					Responsetime: trans["responsetime"].(int),
					Status:       trans["status"].(string),
				}
			}
		}
		close(transChan)
	}()

	inserted, err := testdata.InsertInEsFromChan(es, index_name, transChan)
	if err != nil {
		fmt.Println("Error: ", err)
	}

	fmt.Printf("%d transactions inserted into %s\n", inserted, index_name)

	// set back the refreshing interval
	_, err = es.Request("PUT", index_name, "_settings", bytes.NewBufferString(
		`{"index": {"refresh_interval": "1s"}}`,
	))
	if err != nil {
		fmt.Println("Error: ", err)
	}
}
Beispiel #5
0
func DeleteTestData(index string) error {
	es := elasticsearch.NewElasticsearch()
	_, err := es.DeleteIndex(index)
	es.Refresh(index)
	return err
}
Beispiel #6
0
func (api *ByDimensionApi) Query(req *ByDimensionRequest) (*ByDimensionResponse, int, error) {

	var esreq EsByDimensionReq
	es := elasticsearch.NewElasticsearch()

	api.setRequestDefaults(req)

	req.interval_seconds = float32(time.Time(req.Timerange.To).Sub(time.Time(req.Timerange.From))) / 1e9

	primary := &esreq.Aggs.Primary
	primary.Terms.Field = req.Config.Primary_dimension

	// set timestamp filter
	esreq.Query.Filtered = MapStr{}
	esreq.Query.Filtered["filter"] = esBuildTimeFilter(
		req.Config.Timestamp_field, req.Timerange)

	aggs, err := api.buildRequestAggs(req)
	if err != nil {
		return nil, 400, err
	}
	primary.Aggs = *aggs

	aggs, err = api.buildRequestHistogramAggs(req)
	if err != nil {
		return nil, 400, err
	}
	for k, v := range *aggs {
		primary.Aggs[k] = v
	}

	// up to here we assume there are client errors, from here on
	// it's on us.

	objreq, err := json.Marshal(&esreq)
	if err != nil {
		return nil, 500, err
	}

	//fmt.Println("Objreq=", string(objreq))

	resp, err := es.Search(api.Index, "?search_type=count",
		string(objreq))
	if err != nil {
		return nil, 500, err
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, 500, err
	}

	var answ struct {
		Aggregations struct {
			Primary struct {
				Buckets []map[string]json.RawMessage
			}
		}
	}

	err = json.Unmarshal(body, &answ)
	if err != nil {
		return nil, 500, err
	}

	var response ByDimensionResponse
	response.Primary = []PrimaryDimension{}

	for _, bucket := range answ.Aggregations.Primary.Buckets {

		primary, err := api.bucketToPrimary(req, bucket)
		if err != nil {
			return nil, 500, err
		}

		response.Primary = append(response.Primary, *primary)
	}

	// if we got so far, we're successful
	response.Status = "ok"

	return &response, 200, nil
}
Beispiel #7
0
func NewByDimensionApi(index string) *ByDimensionApi {
	return &ByDimensionApi{
		es:    elasticsearch.NewElasticsearch(),
		Index: index,
	}
}