prometheus/storage/remote/client.go

// Copyright 2016 The Prometheus Authors
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package remote

import (
	"time"

	"golang.org/x/net/context"
	"google.golang.org/grpc"

	"github.com/prometheus/common/model"
)

// Client allows sending batches of Prometheus samples to an HTTP endpoint.
type Client struct {
	client  WriteClient
	timeout time.Duration
}

// NewClient creates a new Client.
func NewClient(address string, timeout time.Duration) (*Client, error) {
	conn, err := grpc.Dial(
		address,
		grpc.WithInsecure(),
		grpc.WithTimeout(timeout),
		grpc.WithCompressor(&snappyCompressor{}),
	)
	if err != nil {
		// grpc.Dial() returns immediately and doesn't error when the server is
		// unreachable when not passing in the WithBlock() option. The client then
		// will continuously try to (re)establish the connection in the background.
		// So this will only return here if some other uncommon error occured.
		return nil, err
	}
	return &Client{
		client:  NewWriteClient(conn),
		timeout: timeout,
	}, nil
}

// Store sends a batch of samples to the HTTP endpoint.
func (c *Client) Store(samples model.Samples) error {
	req := &WriteRequest{
		Timeseries: make([]*TimeSeries, 0, len(samples)),
	}
	for _, s := range samples {
		ts := &TimeSeries{
			Labels: make([]*LabelPair, 0, len(s.Metric)),
		}
		for k, v := range s.Metric {
			ts.Labels = append(ts.Labels,
				&LabelPair{
					Name:  string(k),
					Value: string(v),
				})
		}
		ts.Samples = []*Sample{
			{
				Value:       float64(s.Value),
				TimestampMs: int64(s.Timestamp),
			},
		}
		req.Timeseries = append(req.Timeseries, ts)
	}

	ctxt, cancel := context.WithTimeout(context.TODO(), c.timeout)
	defer cancel()

	_, err := c.client.Write(ctxt, req)
	if err != nil {
		return err
	}
	return nil
}

// Name identifies the client as a generic client.
//
// TODO: This client is going to be the only one soon - then this method
// will simply be removed in the restructuring and the whole "generic" naming
// will be gone for good.
func (c Client) Name() string {
	return "generic"
}