match

Documentation

Index

• Variables
• type Comparison
• type Source
• type SpanKind
  • func (me SpanKind) Ref() *SpanKind
• type SpanMatcher
  • func (me *SpanMatcher) MarshalHCL(properties hcl.Properties) error
  • func (me *SpanMatcher) Schema() map[string]*schema.Schema
  • func (me *SpanMatcher) UnmarshalHCL(decoder hcl.Decoder) error
• type SpanMatchers
  • func (me SpanMatchers) MarshalHCL(properties hcl.Properties) error
  • func (me *SpanMatchers) Schema() map[string]*schema.Schema
  • func (me *SpanMatchers) UnmarshalHCL(decoder hcl.Decoder) error

Variables

var Comparisons = struct {
	Equals           Comparison
	Contains         Comparison
	StartsWith       Comparison
	EndsWith         Comparison
	DoesNotEqual     Comparison
	DoesNotContain   Comparison
	DoesNotStartWith Comparison
	DoesNotEndWith   Comparison
}{
	Equals:           Comparison("EQUALS"),
	Contains:         Comparison("CONTAINS"),
	StartsWith:       Comparison("STARTS_WITH"),
	EndsWith:         Comparison("ENDS_WITH"),
	DoesNotEqual:     Comparison("DOES_NOT_EQUAL"),
	DoesNotContain:   Comparison("DOES_NOT_CONTAIN"),
	DoesNotStartWith: Comparison("DOES_NOT_START_WITH"),
	DoesNotEndWith:   Comparison("DOES_NOT_END_WITH"),
}

var Sources = struct {
	SpanName                      Source
	SpanKind                      Source
	Attribute                     Source
	InstrumentationLibraryName    Source
	InstrumentationLibraryVersion Source
	InstrumentationScopeName      Source
	InstrumentationScopeVersion   Source
}{
	SpanName:                      Source("SPAN_NAME"),
	SpanKind:                      Source("SPAN_KIND"),
	Attribute:                     Source("ATTRIBUTE"),
	InstrumentationLibraryName:    Source("INSTRUMENTATION_LIBRARY_NAME"),
	InstrumentationLibraryVersion: Source("INSTRUMENTATION_LIBRARY_VERSION"),
	InstrumentationScopeName:      Source("INSTRUMENTATION_SCOPE_NAME"),
	InstrumentationScopeVersion:   Source("INSTRUMENTATION_SCOPE_VERSION"),
}

var SpanKinds = struct {
	Internal SpanKind
	Server   SpanKind
	Client   SpanKind
	Producer SpanKind
	Consumer SpanKind
}{
	Internal: SpanKind("INTERNAL"),
	Server:   SpanKind("SERVER"),
	Client:   SpanKind("CLIENT"),
	Producer: SpanKind("PRODUCER"),
	Consumer: SpanKind("CONSUMER"),
}

Types

type Comparison

type Comparison string

type Source

type Source string

type SpanKind

type SpanKind string

func (SpanKind) Ref

func (me SpanKind) Ref() *SpanKind

type SpanMatcher

type SpanMatcher struct {
	Source        Source     `json:"source"`
	SpanKindValue *SpanKind  `json:"spanKindValue"`
	Type          Comparison `json:"type"`
	SourceKey     *string    `json:"sourceKey"`
	Value         *string    `json:"value"`
	CaseSensitive bool       `json:"caseSensitive"`
}

func (*SpanMatcher) MarshalHCL

func (me *SpanMatcher) MarshalHCL(properties hcl.Properties) error

func (*SpanMatcher) Schema

func (me *SpanMatcher) Schema() map[string]*schema.Schema

func (*SpanMatcher) UnmarshalHCL

func (me *SpanMatcher) UnmarshalHCL(decoder hcl.Decoder) error

type SpanMatchers

type SpanMatchers []*SpanMatcher

func (SpanMatchers) MarshalHCL

func (me SpanMatchers) MarshalHCL(properties hcl.Properties) error

func (*SpanMatchers) Schema

func (me *SpanMatchers) Schema() map[string]*schema.Schema

func (*SpanMatchers) UnmarshalHCL

func (me *SpanMatchers) UnmarshalHCL(decoder hcl.Decoder) error