README

OTLP Receiver

Receives data via gRPC or HTTP using OTLP format.

Supported pipeline types: traces, metrics, logs

⚠️ OTLP metrics format is currently marked as "Alpha" and may change in incompatible way any time.

Getting Started

All that is required to enable the OTLP receiver is to include it in the receiver definitions. A protocol can be disabled by simply not specifying it in the list of protocols.

receivers:
  otlp:
    protocols:
      grpc:
      http:

The following settings are configurable:

Advanced Configuration

Several helper files are leveraged to provide additional capabilities automatically:

Writing with HTTP/JSON

The OTLP 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/traces for traces, to [address]/v1/metrics for metrics, to [address]/v1/logs for logs. The default port is 55681.

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 and optionally headers in cors_allowed_headers:

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
        cors_allowed_headers:
        - TestHeader
Expand ▾ Collapse ▴

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

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

      NewFactory creates a new OTLP receiver factory.

      Types

      type Config

      type Config struct {
      	config.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.

        func (*Config) Validate

        func (cfg *Config) Validate() error

          Validate checks the receiver configuration is valid

          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"`
                            }

                              Protocols is the configuration for the supported protocols.

                              Directories

                              Path Synopsis