otel: go.opentelemetry.io/otel/exporters/metric/prometheus Index | Examples | Files

package prometheus

import "go.opentelemetry.io/otel/exporters/metric/prometheus"

Index

Examples

Package Files

prometheus.go sanitize.go

Variables

❖
var ErrUnsupportedAggregator = fmt.Errorf("unsupported aggregator type")

ErrUnsupportedAggregator is returned for unrepresentable aggregator types (e.g., exact).

type Config Uses

❖
type Config struct {
    // Registry is the prometheus registry that will be used as the default Registerer and
    // Gatherer if these are not specified.
    //
    // If not set a new empty Registry is created.
    Registry *prometheus.Registry

    // Registerer is the prometheus registerer to register
    // metrics with.
    //
    // If not specified the Registry will be used as default.
    Registerer prometheus.Registerer

    // Gatherer is the prometheus gatherer to gather
    // metrics with.
    //
    // If not specified the Registry will be used as default.
    Gatherer prometheus.Gatherer

    // DefaultHistogramBoundaries defines the default histogram bucket
    // boundaries.
    DefaultHistogramBoundaries []float64
}

Config is a set of configs for the tally reporter.

type Exporter Uses

❖
type Exporter struct {
    // contains filtered or unexported fields
}

Exporter supports Prometheus pulls. It does not implement the sdk/export/metric.Exporter interface--instead it creates a pull controller and reads the latest checkpointed data on-scrape.

func InstallNewPipeline Uses

❖
func InstallNewPipeline(config Config, options ...controller.Option) (*Exporter, error)

InstallNewPipeline instantiates a NewExportPipeline and registers it globally. Typically called as: 

hf, err := prometheus.InstallNewPipeline(prometheus.Config{...})

if err != nil {
	...
}
http.HandleFunc("/metrics", hf)
defer pipeline.Stop()
... Done

func NewExportPipeline Uses

❖
func NewExportPipeline(config Config, options ...controller.Option) (*Exporter, error)

NewExportPipeline sets up a complete export pipeline with the recommended setup, using the recommended selector and standard processor. See the controller.Options.

Example

Code: 

// Create a resource, with builtin attributes plus R=V.
res, err := resource.New(
    context.Background(),
    resource.WithoutBuiltin(), // Test-only!
    resource.WithAttributes(label.String("R", "V")),
)
if err != nil {
    panic(err)
}

// Create a meter
exporter, err := prometheus.NewExportPipeline(
    prometheus.Config{},
    controller.WithResource(res),
)
if err != nil {
    panic(err)
}
meter := exporter.MeterProvider().Meter("example")
ctx := context.Background()

// Use two instruments
counter := metric.Must(meter).NewInt64Counter(
    "a.counter",
    metric.WithDescription("Counts things"),
)
recorder := metric.Must(meter).NewInt64ValueRecorder(
    "a.valuerecorder",
    metric.WithDescription("Records values"),
)

counter.Add(ctx, 100, label.String("key", "value"))
recorder.Record(ctx, 100, label.String("key", "value"))

// GET the HTTP endpoint
var input bytes.Buffer
resp := httptest.NewRecorder()
req, err := http.NewRequest("GET", "/", &input)
if err != nil {
    panic(err)
}
exporter.ServeHTTP(resp, req)
data, err := ioutil.ReadAll(resp.Result().Body)
if err != nil {
    panic(err)
}
fmt.Print(string(data))

Output:

# HELP a_counter Counts things
# TYPE a_counter counter
a_counter{R="V",key="value"} 100
# HELP a_valuerecorder Records values
# TYPE a_valuerecorder histogram
a_valuerecorder_bucket{R="V",key="value",le="+Inf"} 1
a_valuerecorder_sum{R="V",key="value"} 100
a_valuerecorder_count{R="V",key="value"} 1

func NewExporter Uses

❖
func NewExporter(config Config, controller *controller.Controller) (*Exporter, error)

NewExporter returns a new Prometheus exporter using the configured metric controller. See controller.New().

func (*Exporter) Controller Uses

❖
func (e *Exporter) Controller() *controller.Controller

Controller returns the controller object that coordinates collection for the SDK.

func (*Exporter) ExportKindFor Uses

❖
func (e *Exporter) ExportKindFor(desc *metric.Descriptor, kind aggregation.Kind) export.ExportKind

ExportKindFor implements ExportKindSelector.

func (*Exporter) MeterProvider Uses

❖
func (e *Exporter) MeterProvider() metric.MeterProvider

MeterProvider returns the MeterProvider of this exporter.

func (*Exporter) ServeHTTP Uses

❖
func (e *Exporter) ServeHTTP(w http.ResponseWriter, r *http.Request)

ServeHTTP implements http.Handler.

Package prometheus imports 18 packages (graph) and is imported by 12 packages. Updated 2021-01-16. Refresh now. Tools for package owners.