otlpreceiver

README

OpenTelemetry Receiver

Receives traces and/or metrics via gRPC using OpenTelemetry format.

To get started, all that is required to enable the OpenTelemetry receiver is to include it in the receiver definitions.

The following settings are required:

• endpoint (default = 0.0.0.0:55680): host:port to which the exporter is going to receive traces or metrics, using the gRPC protocol. The valid syntax is described at https://github.com/grpc/grpc/blob/master/doc/naming.md.
• transport (default = tcp): which transport to use between tcp and unix.

The following settings are optional:

• cors_allowed_origins (default = unset): allowed CORS origins for HTTP/JSON requests. See the HTTP/JSON section below.
• keepalive: see https://godoc.org/google.golang.org/grpc/keepalive#ServerParameters for more information
  • MaxConnectionIdle (default = infinity)
  • MaxConnectionAge (default = infinity)
  • MaxConnectionAgeGrace (default = infinity)
  • Time (default = 2h)
  • Timeout (default = 20s)
• max_recv_msg_size_mib (default = 4MB): sets the maximum size of messages accepted
• max_concurrent_streams: sets the limit on the number of concurrent streams
• tls_credentials (default = unset): configures the receiver to use TLS. See TLS section below.

Examples:

receivers:
  otlp:
    protocols:
        grpc:
  otlp/withendpoint:
    protocols:
        grpc:
            endpoint: 127.0.0.1:55680

The full list of settings exposed for this receiver are documented here with detailed sample configurations here.

A protocol can be disabled by simply not specifying it in the list of protocols:

receivers:
  otlp/only_grpc:
    protocols:
      grpc:

Communicating over TLS

This receiver supports communication using Transport Layer Security (TLS). TLS can be configured by specifying a tls_settings object in the receiver configuration for receivers that support it.

receivers:
  otlp:
    protocols:
      grpc:
        tls_settings:
          key_file: /key.pem # path to private key
          cert_file: /cert.pem # path to certificate

Writing with HTTP/JSON

The OpenTelemetry receiver can receive trace export calls via HTTP/JSON in addition to gRPC. The HTTP/JSON address is the same as gRPC as the protocol is recognized and processed accordingly. Note the format needs to be protobuf JSON serialization.

IMPORTANT: bytes fields are encoded as base64 strings.

To write traces with HTTP/JSON, POST to [address]/v1/trace.

The HTTP/JSON endpoint can also optionally configure CORS, which is enabled by specifying a list of allowed CORS origins in the cors_allowed_origins field:

receivers:
  otlp:
    protocols:
      http:
        endpoint: "localhost:55681"
        cors_allowed_origins:
        - http://test.com
        # Origins can have wildcards with *, use * by itself to match any origin.
        - https://*.example.com

Documentation

Index

• func DisallowUnknownFields()
• func NewFactory() component.ReceiverFactory
• type Config
• type DecoderWrapper
  • func (d DecoderWrapper) Decode(v interface{}) error
• type JSONPb
  • func (*JSONPb) ContentType() string
  • func (j *JSONPb) Delimiter() []byte
  • func (j *JSONPb) Marshal(v interface{}) ([]byte, error)
  • func (j *JSONPb) NewDecoder(r io.Reader) runtime.Decoder
  • func (j *JSONPb) NewEncoder(w io.Writer) runtime.Encoder
  • func (j *JSONPb) Unmarshal(data []byte, v interface{}) error
• type Protocols

Functions

func DisallowUnknownFields

func DisallowUnknownFields()

DisallowUnknownFields enables option in decoder (unmarshaller) to return an error when it finds an unknown field. This function must be called before using the JSON marshaller.

func NewFactory

func NewFactory() component.ReceiverFactory

Types

type Config

type Config struct {
	configmodels.ReceiverSettings `mapstructure:",squash"` // squash ensures fields are correctly decoded in embedded struct

	// Protocols is the configuration for the supported protocols, currently gRPC and HTTP (Proto and JSON).
	Protocols `mapstructure:"protocols"`
}

Config defines configuration for OTLP receiver.

type DecoderWrapper

type DecoderWrapper struct {
	*json.Decoder
}

DecoderWrapper is a wrapper around a *json.Decoder that adds support for protos to the Decode method.

func (DecoderWrapper) Decode

func (d DecoderWrapper) Decode(v interface{}) error

Decode wraps the embedded decoder's Decode method to support protos using a jsonpb.Unmarshaler.

type JSONPb

type JSONPb jsonpb.Marshaler

JSONPb is a Marshaler which marshals/unmarshals into/from JSON with the "github.com/golang/protobuf/jsonpb". It supports fully functionality of protobuf unlike JSONBuiltin.

The NewDecoder method returns a DecoderWrapper, so the underlying *json.Decoder methods can be used.

func (*JSONPb) ContentType

func (*JSONPb) ContentType() string

ContentType always returns "application/json".

func (*JSONPb) Delimiter

func (j *JSONPb) Delimiter() []byte

Delimiter for newline encoded JSON streams.

func (*JSONPb) Marshal

func (j *JSONPb) Marshal(v interface{}) ([]byte, error)

Marshal marshals "v" into JSON.

func (*JSONPb) NewDecoder

func (j *JSONPb) NewDecoder(r io.Reader) runtime.Decoder

NewDecoder returns a Decoder which reads JSON stream from "r".

func (*JSONPb) NewEncoder

func (j *JSONPb) NewEncoder(w io.Writer) runtime.Encoder

NewEncoder returns an Encoder which writes JSON stream into "w".

func (*JSONPb) Unmarshal

func (j *JSONPb) Unmarshal(data []byte, v interface{}) error

Unmarshal unmarshals JSON "data" into "v"

type Protocols

type Protocols struct {
	GRPC *configgrpc.GRPCServerSettings `mapstructure:"grpc"`
	HTTP *confighttp.HTTPServerSettings `mapstructure:"http"`
}