openpipeline

package
v1.69.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 18, 2024 License: Apache-2.0 Imports: 5 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	ClassicPipelineType = "classic"
	DefaultPipelineType = "default"
)
View Source 
const (
	DqlProcessorType          = "dql"
	FieldsAddProcessorType    = "fieldsAdd"
	FieldsRemoveProcessorType = "fieldsRemove"
	FieldsRenameProcessorType = "fieldsRename"

	CounterMetricProcessorType = "counterMetric"
	ValueMetricProcessorType   = "valueMetric"

	DavisEventExtractionProcessorType = "davis"
	BizEventExtractionProcessorType   = "bizevent"

	SecurityContextProcessorType = "securityContext"

	NoStorageStageProcessorType        = "noStorage"
	BucketAssignmentStageProcessorType = "bucketAssignment"

	TechnologyProcessorType = "technology"
	SqlxProcessorType       = "sqlx"
)
View Source 
const (
	StaticRoutingType  = "static"
	DynamicRoutingType = "dynamic"
)

Variables

This section is empty.

Functions

func ExtractType 

func ExtractType(message json.RawMessage) (string, error)

ExtractType extracts the value of type field as a string from the specified raw message.

func MarshalAsJSONWithType 

func MarshalAsJSONWithType(v any, ttype string) (json.RawMessage, error)

MarshalAsJSONWithType converts the specified value to JSON with an additional type field.

Types

type BasePipeline 

type BasePipeline struct {
	Builtin          *bool                  `json:"builtin,omitempty"`
	DataExtraction   *DataExtractionStage   `json:"dataExtraction"`
	DisplayName      *string                `json:"displayName,omitempty"`
	Editable         *bool                  `json:"editable,omitempty"`
	Enabled          bool                   `json:"enabled"`
	Id               string                 `json:"id"`
	MetricExtraction *MetricExtractionStage `json:"metricExtraction,omitempty"`
	SecurityContext  *SecurityContextStage  `json:"securityContext"`
	Storage          *StorageStage          `json:"storage,omitempty"`
	Type             string                 `json:"type"`
}

func (*BasePipeline) IsFixed 

func (ep *BasePipeline) IsFixed() bool

func (*BasePipeline) MarshalHCL 

func (ep *BasePipeline) MarshalHCL(properties hcl.Properties) error

func (*BasePipeline) Schema 

func (ep *BasePipeline) Schema() map[string]*schema.Schema

func (*BasePipeline) UnmarshalHCL 

func (ep *BasePipeline) UnmarshalHCL(decoder hcl.Decoder) error

type BizEventExtractionProcessor 

type BizEventExtractionProcessor struct {
	Processor
	EventProvider   *ValueAssignment `json:"eventProvider,omitempty"`
	EventType       *ValueAssignment `json:"eventType,omitempty"`
	FieldExtraction *FieldExtraction `json:"fieldExtraction,omitempty"`
}

func (*BizEventExtractionProcessor) MarshalHCL 

func (ep *BizEventExtractionProcessor) MarshalHCL(properties hcl.Properties) error

func (BizEventExtractionProcessor) MarshalJSON 

func (ep BizEventExtractionProcessor) MarshalJSON() ([]byte, error)

func (*BizEventExtractionProcessor) Schema 

func (ep *BizEventExtractionProcessor) Schema() map[string]*schema.Schema

func (*BizEventExtractionProcessor) UnmarshalHCL 

func (ep *BizEventExtractionProcessor) UnmarshalHCL(decoder hcl.Decoder) error

type BucketAssignmentProcessor 

type BucketAssignmentProcessor struct {
	Processor
	BucketName string `json:"bucketName"`
}

func (*BucketAssignmentProcessor) MarshalHCL 

func (p *BucketAssignmentProcessor) MarshalHCL(properties hcl.Properties) error

func (BucketAssignmentProcessor) MarshalJSON 

func (ep BucketAssignmentProcessor) MarshalJSON() ([]byte, error)

func (*BucketAssignmentProcessor) Schema 

func (p *BucketAssignmentProcessor) Schema() map[string]*schema.Schema

func (*BucketAssignmentProcessor) UnmarshalHCL 

func (p *BucketAssignmentProcessor) UnmarshalHCL(decoder hcl.Decoder) error

type ClassicPipeline 

type ClassicPipeline struct {
	BasePipeline
	Processing     *ClassicProcessingStage `json:"processing,omitempty"`
	SettingsSchema string                  `json:"settingsSchema,omitempty"`
}

func (ClassicPipeline) MarshalJSON 

func (p ClassicPipeline) MarshalJSON() ([]byte, error)

type ClassicProcessingStage 

type ClassicProcessingStage struct {
	Editable   *bool                              `json:"editable,omitempty"`
	Processors []*ClassicProcessingStageProcessor `json:"processors"`
}

type ClassicProcessingStageProcessor 

type ClassicProcessingStageProcessor struct {
	// contains filtered or unexported fields
}

func (ClassicProcessingStageProcessor) MarshalJSON 

func (ep ClassicProcessingStageProcessor) MarshalJSON() ([]byte, error)

func (*ClassicProcessingStageProcessor) UnmarshalJSON 

func (ep *ClassicProcessingStageProcessor) UnmarshalJSON(b []byte) error

type Configuration 

type Configuration struct {
	Kind           string        `json:"id"`
	Editable       *bool         `json:"editable,omitempty"`
	Version        string        `json:"version"`
	CustomBasePath string        `json:"customBasePath"`
	Endpoints      *Endpoints    `json:"-"`
	Pipelines      *Pipelines    `json:"-"`
	Routing        *RoutingTable `json:"routing"`
}

func (*Configuration) MarshalHCL 

func (d *Configuration) MarshalHCL(properties hcl.Properties) error

func (Configuration) MarshalJSON 

func (d Configuration) MarshalJSON() ([]byte, error)

func (*Configuration) Name 

func (d *Configuration) Name() string

func (*Configuration) RemoveFixed 

func (d *Configuration) RemoveFixed()

func (*Configuration) Schema 

func (d *Configuration) Schema() map[string]*schema.Schema

func (*Configuration) UnmarshalHCL 

func (d *Configuration) UnmarshalHCL(decoder hcl.Decoder) error

func (*Configuration) UnmarshalJSON 

func (d *Configuration) UnmarshalJSON(b []byte) error

type CounterMetricExtractionProcessor 

type CounterMetricExtractionProcessor struct {
	Processor
	Dimensions []string `json:"dimensions,omitempty"`
	MetricKey  string   `json:"metricKey"`
}

func (*CounterMetricExtractionProcessor) MarshalHCL 

func (p *CounterMetricExtractionProcessor) MarshalHCL(properties hcl.Properties) error

func (CounterMetricExtractionProcessor) MarshalJSON 

func (ep CounterMetricExtractionProcessor) MarshalJSON() ([]byte, error)

func (*CounterMetricExtractionProcessor) Schema 

func (p *CounterMetricExtractionProcessor) Schema() map[string]*schema.Schema

func (*CounterMetricExtractionProcessor) UnmarshalHCL 

func (p *CounterMetricExtractionProcessor) UnmarshalHCL(decoder hcl.Decoder) error

type DataExtractionProcessor 

type DataExtractionProcessor struct {
	// contains filtered or unexported fields
}

func (*DataExtractionProcessor) MarshalHCL 

func (ep *DataExtractionProcessor) MarshalHCL(properties hcl.Properties) error

func (DataExtractionProcessor) MarshalJSON 

func (ep DataExtractionProcessor) MarshalJSON() ([]byte, error)

func (*DataExtractionProcessor) Schema 

func (ep *DataExtractionProcessor) Schema() map[string]*schema.Schema

func (*DataExtractionProcessor) UnmarshalHCL 

func (ep *DataExtractionProcessor) UnmarshalHCL(decoder hcl.Decoder) error

func (*DataExtractionProcessor) UnmarshalJSON 

func (ep *DataExtractionProcessor) UnmarshalJSON(b []byte) error

type DataExtractionStage 

type DataExtractionStage struct {
	Editable   *bool                      `json:"editable,omitempty"`
	Processors []*DataExtractionProcessor `json:"processors"`
}

func (*DataExtractionStage) MarshalHCL 

func (f *DataExtractionStage) MarshalHCL(properties hcl.Properties) error

func (*DataExtractionStage) Schema 

func (f *DataExtractionStage) Schema() map[string]*schema.Schema

func (*DataExtractionStage) UnmarshalHCL 

func (f *DataExtractionStage) UnmarshalHCL(decoder hcl.Decoder) error

type DavisEventExtractionProcessor 

type DavisEventExtractionProcessor struct {
	Processor
	Properties []*DavisEventProperty `json:"properties,omitempty"`
}

func (*DavisEventExtractionProcessor) MarshalHCL 

func (ep *DavisEventExtractionProcessor) MarshalHCL(properties hcl.Properties) error

func (DavisEventExtractionProcessor) MarshalJSON 

func (p DavisEventExtractionProcessor) MarshalJSON() ([]byte, error)

func (*DavisEventExtractionProcessor) Schema 

func (ep *DavisEventExtractionProcessor) Schema() map[string]*schema.Schema

func (*DavisEventExtractionProcessor) UnmarshalHCL 

func (ep *DavisEventExtractionProcessor) UnmarshalHCL(decoder hcl.Decoder) error

type DavisEventProperty 

type DavisEventProperty struct {
	Key   string `json:"key"`
	Value string `json:"value"`
}

func (*DavisEventProperty) MarshalHCL 

func (ep *DavisEventProperty) MarshalHCL(properties hcl.Properties) error

func (*DavisEventProperty) Schema 

func (ep *DavisEventProperty) Schema() map[string]*schema.Schema

func (*DavisEventProperty) UnmarshalHCL 

func (ep *DavisEventProperty) UnmarshalHCL(decoder hcl.Decoder) error

type DefaultPipeline 

type DefaultPipeline struct {
	BasePipeline
	Processing *ProcessingStage `json:"processing,omitempty"`
}

func (*DefaultPipeline) MarshalHCL 

func (p *DefaultPipeline) MarshalHCL(properties hcl.Properties) error

func (DefaultPipeline) MarshalJSON 

func (p DefaultPipeline) MarshalJSON() ([]byte, error)

func (*DefaultPipeline) Schema 

func (p *DefaultPipeline) Schema() map[string]*schema.Schema

func (*DefaultPipeline) UnmarshalHCL 

func (p *DefaultPipeline) UnmarshalHCL(decoder hcl.Decoder) error

type DqlProcessor 

type DqlProcessor struct {
	Processor
	DqlScript string `json:"dqlScript"`
}

func (*DqlProcessor) MarshalHCL 

func (p *DqlProcessor) MarshalHCL(properties hcl.Properties) error

func (DqlProcessor) MarshalJSON 

func (ep DqlProcessor) MarshalJSON() ([]byte, error)

func (*DqlProcessor) Schema 

func (p *DqlProcessor) Schema() map[string]*schema.Schema

func (*DqlProcessor) UnmarshalHCL 

func (p *DqlProcessor) UnmarshalHCL(decoder hcl.Decoder) error

type EndpointDefinition 

type EndpointDefinition struct {
	BasePath      string              `json:"basePath"`
	Builtin       *bool               `json:"builtin,omitempty"`
	DefaultBucket *string             `json:"defaultBucket,omitempty"`
	DisplayName   *string             `json:"displayName,omitempty"`
	Editable      *bool               `json:"editable,omitempty"`
	Enabled       bool                `json:"enabled"`
	Segment       string              `json:"segment"`
	Routing       *Routing            `json:"routing"`
	Processors    *EndpointProcessors `json:"-"`
}

func (*EndpointDefinition) IsFixed 

func (d *EndpointDefinition) IsFixed() bool

func (*EndpointDefinition) MarshalHCL 

func (d *EndpointDefinition) MarshalHCL(properties hcl.Properties) error

func (EndpointDefinition) MarshalJSON 

func (d EndpointDefinition) MarshalJSON() ([]byte, error)

func (*EndpointDefinition) Schema 

func (d *EndpointDefinition) Schema() map[string]*schema.Schema

func (*EndpointDefinition) UnmarshalHCL 

func (d *EndpointDefinition) UnmarshalHCL(decoder hcl.Decoder) error

func (*EndpointDefinition) UnmarshalJSON 

func (d *EndpointDefinition) UnmarshalJSON(b []byte) error

type EndpointProcessor 

type EndpointProcessor struct {
	// contains filtered or unexported fields
}

func (*EndpointProcessor) MarshalHCL 

func (ep *EndpointProcessor) MarshalHCL(properties hcl.Properties) error

func (EndpointProcessor) MarshalJSON 

func (ep EndpointProcessor) MarshalJSON() ([]byte, error)

func (*EndpointProcessor) Schema 

func (ep *EndpointProcessor) Schema() map[string]*schema.Schema

func (*EndpointProcessor) UnmarshalHCL 

func (ep *EndpointProcessor) UnmarshalHCL(decoder hcl.Decoder) error

func (*EndpointProcessor) UnmarshalJSON 

func (ep *EndpointProcessor) UnmarshalJSON(b []byte) error

type EndpointProcessors 

type EndpointProcessors struct {
	Processors []*EndpointProcessor
}

func (*EndpointProcessors) MarshalHCL 

func (ep *EndpointProcessors) MarshalHCL(properties hcl.Properties) error

func (EndpointProcessors) MarshalJSON 

func (ep EndpointProcessors) MarshalJSON() ([]byte, error)

func (*EndpointProcessors) Schema 

func (ep *EndpointProcessors) Schema() map[string]*schema.Schema

func (*EndpointProcessors) UnmarshalHCL 

func (ep *EndpointProcessors) UnmarshalHCL(decoder hcl.Decoder) error

func (*EndpointProcessors) UnmarshalJSON 

func (ep *EndpointProcessors) UnmarshalJSON(b []byte) error

type Endpoints 

type Endpoints struct {
	Endpoints []*EndpointDefinition
}

func (*Endpoints) MarshalHCL 

func (ep *Endpoints) MarshalHCL(properties hcl.Properties) error

func (Endpoints) MarshalJSON 

func (d Endpoints) MarshalJSON() ([]byte, error)

func (*Endpoints) RemoveFixed 

func (ep *Endpoints) RemoveFixed()

func (*Endpoints) Schema 

func (ep *Endpoints) Schema() map[string]*schema.Schema

func (*Endpoints) UnmarshalHCL 

func (ep *Endpoints) UnmarshalHCL(decoder hcl.Decoder) error

func (*Endpoints) UnmarshalJSON 

func (d *Endpoints) UnmarshalJSON(data []byte) error

type FieldExtraction 

type FieldExtraction struct {
	Fields   []string `json:"fields"`
	Semantic string   `json:"semantic"`
}

func (*FieldExtraction) MarshalHCL 

func (ep *FieldExtraction) MarshalHCL(properties hcl.Properties) error

func (*FieldExtraction) Schema 

func (ep *FieldExtraction) Schema() map[string]*schema.Schema

func (*FieldExtraction) UnmarshalHCL 

func (ep *FieldExtraction) UnmarshalHCL(decoder hcl.Decoder) error

type FieldsAddItem 

type FieldsAddItem struct {
	Name  string `json:"name"`
	Value string `json:"value"`
}

func (*FieldsAddItem) MarshalHCL 

func (f *FieldsAddItem) MarshalHCL(properties hcl.Properties) error

func (*FieldsAddItem) Schema 

func (f *FieldsAddItem) Schema() map[string]*schema.Schema

func (*FieldsAddItem) UnmarshalHCL 

func (f *FieldsAddItem) UnmarshalHCL(decoder hcl.Decoder) error

type FieldsAddProcessor 

type FieldsAddProcessor struct {
	Processor
	Fields []*FieldsAddItem `json:"fields"`
}

func (*FieldsAddProcessor) MarshalHCL 

func (p *FieldsAddProcessor) MarshalHCL(properties hcl.Properties) error

func (FieldsAddProcessor) MarshalJSON 

func (ep FieldsAddProcessor) MarshalJSON() ([]byte, error)

func (*FieldsAddProcessor) Schema 

func (p *FieldsAddProcessor) Schema() map[string]*schema.Schema

func (*FieldsAddProcessor) UnmarshalHCL 

func (p *FieldsAddProcessor) UnmarshalHCL(decoder hcl.Decoder) error

type FieldsRemoveProcessor 

type FieldsRemoveProcessor struct {
	Processor
	Fields []string `json:"fields"`
}

func (*FieldsRemoveProcessor) MarshalHCL 

func (p *FieldsRemoveProcessor) MarshalHCL(properties hcl.Properties) error

func (FieldsRemoveProcessor) MarshalJSON 

func (ep FieldsRemoveProcessor) MarshalJSON() ([]byte, error)

func (*FieldsRemoveProcessor) Schema 

func (p *FieldsRemoveProcessor) Schema() map[string]*schema.Schema

func (*FieldsRemoveProcessor) UnmarshalHCL 

func (p *FieldsRemoveProcessor) UnmarshalHCL(decoder hcl.Decoder) error

type FieldsRenameItem 

type FieldsRenameItem struct {
	FromName string `json:"fromName"`
	ToName   string `json:"toName"`
}

func (*FieldsRenameItem) MarshalHCL 

func (f *FieldsRenameItem) MarshalHCL(properties hcl.Properties) error

func (*FieldsRenameItem) Schema 

func (f *FieldsRenameItem) Schema() map[string]*schema.Schema

func (*FieldsRenameItem) UnmarshalHCL 

func (f *FieldsRenameItem) UnmarshalHCL(decoder hcl.Decoder) error

type FieldsRenameProcessor 

type FieldsRenameProcessor struct {
	Processor
	Fields []*FieldsRenameItem `json:"fields"`
}

func (*FieldsRenameProcessor) MarshalHCL 

func (p *FieldsRenameProcessor) MarshalHCL(properties hcl.Properties) error

func (FieldsRenameProcessor) MarshalJSON 

func (ep FieldsRenameProcessor) MarshalJSON() ([]byte, error)

func (*FieldsRenameProcessor) Schema 

func (p *FieldsRenameProcessor) Schema() map[string]*schema.Schema

func (*FieldsRenameProcessor) UnmarshalHCL 

func (p *FieldsRenameProcessor) UnmarshalHCL(decoder hcl.Decoder) error

type MetricExtractionProcessor 

type MetricExtractionProcessor struct {
	// contains filtered or unexported fields
}

func (*MetricExtractionProcessor) MarshalHCL 

func (ep *MetricExtractionProcessor) MarshalHCL(properties hcl.Properties) error

func (MetricExtractionProcessor) MarshalJSON 

func (ep MetricExtractionProcessor) MarshalJSON() ([]byte, error)

func (*MetricExtractionProcessor) Schema 

func (ep *MetricExtractionProcessor) Schema() map[string]*schema.Schema

func (*MetricExtractionProcessor) UnmarshalHCL 

func (ep *MetricExtractionProcessor) UnmarshalHCL(decoder hcl.Decoder) error

func (*MetricExtractionProcessor) UnmarshalJSON 

func (ep *MetricExtractionProcessor) UnmarshalJSON(b []byte) error

type MetricExtractionStage 

type MetricExtractionStage struct {
	Editable   *bool                        `json:"editable,omitempty"`
	Processors []*MetricExtractionProcessor `json:"processors"`
}

func (*MetricExtractionStage) MarshalHCL 

func (f *MetricExtractionStage) MarshalHCL(properties hcl.Properties) error

func (*MetricExtractionStage) Schema 

func (f *MetricExtractionStage) Schema() map[string]*schema.Schema

func (*MetricExtractionStage) UnmarshalHCL 

func (f *MetricExtractionStage) UnmarshalHCL(decoder hcl.Decoder) error

type NoStorageProcessor 

type NoStorageProcessor struct {
	Processor
}

func (*NoStorageProcessor) MarshalHCL 

func (p *NoStorageProcessor) MarshalHCL(properties hcl.Properties) error

func (NoStorageProcessor) MarshalJSON 

func (ep NoStorageProcessor) MarshalJSON() ([]byte, error)

func (*NoStorageProcessor) Schema 

func (p *NoStorageProcessor) Schema() map[string]*schema.Schema

func (*NoStorageProcessor) UnmarshalHCL 

func (p *NoStorageProcessor) UnmarshalHCL(decoder hcl.Decoder) error

type Pipeline 

type Pipeline struct {
	// contains filtered or unexported fields
}

func (*Pipeline) IsFixed 

func (ep *Pipeline) IsFixed() bool

func (*Pipeline) MarshalHCL 

func (ep *Pipeline) MarshalHCL(properties hcl.Properties) error

func (Pipeline) MarshalJSON 

func (ep Pipeline) MarshalJSON() ([]byte, error)

func (*Pipeline) Schema 

func (ep *Pipeline) Schema() map[string]*schema.Schema

func (*Pipeline) UnmarshalHCL 

func (ep *Pipeline) UnmarshalHCL(decoder hcl.Decoder) error

func (*Pipeline) UnmarshalJSON 

func (ep *Pipeline) UnmarshalJSON(b []byte) error

type Pipelines 

type Pipelines struct {
	Pipelines []*Pipeline
}

func (*Pipelines) MarshalHCL 

func (ep *Pipelines) MarshalHCL(properties hcl.Properties) error

func (Pipelines) MarshalJSON 

func (d Pipelines) MarshalJSON() ([]byte, error)

func (*Pipelines) RemoveFixed 

func (d *Pipelines) RemoveFixed()

func (*Pipelines) Schema 

func (ep *Pipelines) Schema() map[string]*schema.Schema

func (*Pipelines) UnmarshalHCL 

func (ep *Pipelines) UnmarshalHCL(decoder hcl.Decoder) error

func (*Pipelines) UnmarshalJSON 

func (d *Pipelines) UnmarshalJSON(data []byte) error

type ProcessingStage 

type ProcessingStage struct {
	Editable   *bool                       `json:"editable,omitempty"`
	Processors []*ProcessingStageProcessor `json:"processors"`
}

func (*ProcessingStage) MarshalHCL 

func (f *ProcessingStage) MarshalHCL(properties hcl.Properties) error

func (*ProcessingStage) Schema 

func (f *ProcessingStage) Schema() map[string]*schema.Schema

func (*ProcessingStage) UnmarshalHCL 

func (f *ProcessingStage) UnmarshalHCL(decoder hcl.Decoder) error

type ProcessingStageProcessor 

type ProcessingStageProcessor struct {
	// contains filtered or unexported fields
}

func (*ProcessingStageProcessor) MarshalHCL 

func (ep *ProcessingStageProcessor) MarshalHCL(properties hcl.Properties) error

func (ProcessingStageProcessor) MarshalJSON 

func (ep ProcessingStageProcessor) MarshalJSON() ([]byte, error)

func (*ProcessingStageProcessor) Schema 

func (ep *ProcessingStageProcessor) Schema() map[string]*schema.Schema

func (*ProcessingStageProcessor) UnmarshalHCL 

func (ep *ProcessingStageProcessor) UnmarshalHCL(decoder hcl.Decoder) error

func (*ProcessingStageProcessor) UnmarshalJSON 

func (ep *ProcessingStageProcessor) UnmarshalJSON(b []byte) error

type Processor 

type Processor struct {
	Description string  `json:"description"`
	Editable    *bool   `json:"editable,omitempty"`
	Enabled     bool    `json:"enabled"`
	Id          string  `json:"id"`
	Matcher     string  `json:"matcher"`
	SampleData  *string `json:"sampleData,omitempty"`
}

func (*Processor) MarshalHCL 

func (p *Processor) MarshalHCL(properties hcl.Properties) error

func (*Processor) Schema 

func (p *Processor) Schema() map[string]*schema.Schema

func (*Processor) UnmarshalHCL 

func (p *Processor) UnmarshalHCL(decoder hcl.Decoder) error

type Routing 

type Routing struct {
	Type       string  `json:"type"`
	PipelineId *string `json:"pipelineId,omitempty"`
}

func (*Routing) MarshalHCL 

func (ep *Routing) MarshalHCL(properties hcl.Properties) error

func (*Routing) Schema 

func (ep *Routing) Schema() map[string]*schema.Schema

func (*Routing) UnmarshalHCL 

func (ep *Routing) UnmarshalHCL(decoder hcl.Decoder) error

type RoutingTable 

type RoutingTable struct {
	// CatchAllPipeline The default pipeline records are routed into if no dynamic routing entries apply.
	CatchAllPipeline *RoutingTableEntryTarget `json:"catchAllPipeline"`

	// Editable Indicates if the user is allowed to edit this object based on permissions and builtin property.
	Editable *bool `json:"editable,omitempty"`

	// Entries List of all dynamic routes.
	Entries []*RoutingTableEntry `json:"entries"`
}

func (*RoutingTable) MarshalHCL 

func (t *RoutingTable) MarshalHCL(properties hcl.Properties) error

func (*RoutingTable) RemoveFixed 

func (t *RoutingTable) RemoveFixed()

func (*RoutingTable) Schema 

func (t *RoutingTable) Schema() map[string]*schema.Schema

func (*RoutingTable) UnmarshalHCL 

func (t *RoutingTable) UnmarshalHCL(decoder hcl.Decoder) error

type RoutingTableEntry 

type RoutingTableEntry struct {
	// Builtin Indicates if the object is provided by Dynatrace or customer defined.
	Builtin *bool `json:"builtin,omitempty"`

	// Editable Indicates if the user is allowed to edit this object based on permissions and builtin property.
	Editable *bool `json:"editable,omitempty"`

	// Enabled Indicates if the object is active.
	Enabled bool `json:"enabled"`

	// Matcher Matching condition to apply on incoming records.
	Matcher string `json:"matcher"`

	// Note Unique note describing the dynamic route.
	Note string `json:"note"`

	// PipelineId Identifier of the pipeline the record is routed into.
	PipelineId string `json:"pipelineId"`
}

func (*RoutingTableEntry) IsFixed 

func (t *RoutingTableEntry) IsFixed() bool

func (*RoutingTableEntry) MarshalHCL 

func (t *RoutingTableEntry) MarshalHCL(properties hcl.Properties) error

func (*RoutingTableEntry) Schema 

func (e *RoutingTableEntry) Schema() map[string]*schema.Schema

func (*RoutingTableEntry) UnmarshalHCL 

func (t *RoutingTableEntry) UnmarshalHCL(decoder hcl.Decoder) error

type RoutingTableEntryTarget 

type RoutingTableEntryTarget struct {
	// Editable Indicates if the user is allowed to edit this object based on permissions and builtin property.
	Editable *bool `json:"editable,omitempty"`

	// PipelineId Identifier of the pipeline.
	PipelineId string `json:"pipelineId"`
}

type SecContextProcessor 

type SecContextProcessor struct {
	// contains filtered or unexported fields
}

func (*SecContextProcessor) MarshalHCL 

func (ep *SecContextProcessor) MarshalHCL(properties hcl.Properties) error

func (SecContextProcessor) MarshalJSON 

func (ep SecContextProcessor) MarshalJSON() ([]byte, error)

func (*SecContextProcessor) Schema 

func (ep *SecContextProcessor) Schema() map[string]*schema.Schema

func (*SecContextProcessor) UnmarshalHCL 

func (ep *SecContextProcessor) UnmarshalHCL(decoder hcl.Decoder) error

func (*SecContextProcessor) UnmarshalJSON 

func (ep *SecContextProcessor) UnmarshalJSON(b []byte) error

type SecurityContextProcessor 

type SecurityContextProcessor struct {
	Processor
	Value *ValueAssignment `json:"value"`
}

func (*SecurityContextProcessor) MarshalHCL 

func (p *SecurityContextProcessor) MarshalHCL(properties hcl.Properties) error

func (SecurityContextProcessor) MarshalJSON 

func (ep SecurityContextProcessor) MarshalJSON() ([]byte, error)

func (*SecurityContextProcessor) Schema 

func (p *SecurityContextProcessor) Schema() map[string]*schema.Schema

func (*SecurityContextProcessor) UnmarshalHCL 

func (p *SecurityContextProcessor) UnmarshalHCL(decoder hcl.Decoder) error

type SecurityContextStage 

type SecurityContextStage struct {
	Editable           *bool                  `json:"editable"`
	CatchAllBucketName *string                `json:"catchAllBucketName,omitempty"`
	Processors         []*SecContextProcessor `json:"processors"`
}

func (*SecurityContextStage) MarshalHCL 

func (f *SecurityContextStage) MarshalHCL(properties hcl.Properties) error

func (*SecurityContextStage) Schema 

func (f *SecurityContextStage) Schema() map[string]*schema.Schema

func (*SecurityContextStage) UnmarshalHCL 

func (f *SecurityContextStage) UnmarshalHCL(decoder hcl.Decoder) error

type SqlxProcessor 

type SqlxProcessor struct {
	Processor
	SqlxScript string `json:"sqlxScript"`
}

func (*SqlxProcessor) MarshalHCL 

func (p *SqlxProcessor) MarshalHCL(properties hcl.Properties) error

func (*SqlxProcessor) Schema 

func (p *SqlxProcessor) Schema() map[string]*schema.Schema

func (*SqlxProcessor) UnmarshalHCL 

func (p *SqlxProcessor) UnmarshalHCL(decoder hcl.Decoder) error

type StorageStage 

type StorageStage struct {
	Editable           *bool                    `json:"editable,omitempty"`
	CatchAllBucketName string                   `json:"catchAllBucketName"`
	Processors         []*StorageStageProcessor `json:"processors"`
}

func (*StorageStage) MarshalHCL 

func (f *StorageStage) MarshalHCL(properties hcl.Properties) error

func (*StorageStage) Schema 

func (f *StorageStage) Schema() map[string]*schema.Schema

func (*StorageStage) UnmarshalHCL 

func (f *StorageStage) UnmarshalHCL(decoder hcl.Decoder) error

type StorageStageProcessor 

type StorageStageProcessor struct {
	// contains filtered or unexported fields
}

func (*StorageStageProcessor) MarshalHCL 

func (ep *StorageStageProcessor) MarshalHCL(properties hcl.Properties) error

func (StorageStageProcessor) MarshalJSON 

func (ep StorageStageProcessor) MarshalJSON() ([]byte, error)

func (*StorageStageProcessor) Schema 

func (ep *StorageStageProcessor) Schema() map[string]*schema.Schema

func (*StorageStageProcessor) UnmarshalHCL 

func (ep *StorageStageProcessor) UnmarshalHCL(decoder hcl.Decoder) error

func (*StorageStageProcessor) UnmarshalJSON 

func (ep *StorageStageProcessor) UnmarshalJSON(b []byte) error

type TechnologyProcessor 

type TechnologyProcessor struct {
	Processor
	TechnologyId string `json:"technologyId"`
}

func (*TechnologyProcessor) MarshalHCL 

func (p *TechnologyProcessor) MarshalHCL(properties hcl.Properties) error

func (TechnologyProcessor) MarshalJSON 

func (ep TechnologyProcessor) MarshalJSON() ([]byte, error)

func (*TechnologyProcessor) Schema 

func (p *TechnologyProcessor) Schema() map[string]*schema.Schema

func (*TechnologyProcessor) UnmarshalHCL 

func (p *TechnologyProcessor) UnmarshalHCL(decoder hcl.Decoder) error

type ValueAssignment 

type ValueAssignment struct {
	// Type Defines the actual set of fields depending on the value. See one of the following objects:
	Type     string  `json:"type"`
	Field    *string `json:"field"`
	Constant *string `json:"constant,omitempty"`
}

func (*ValueAssignment) MarshalHCL 

func (ep *ValueAssignment) MarshalHCL(properties hcl.Properties) error

func (*ValueAssignment) Schema 

func (ep *ValueAssignment) Schema() map[string]*schema.Schema

func (*ValueAssignment) UnmarshalHCL 

func (ep *ValueAssignment) UnmarshalHCL(decoder hcl.Decoder) error

type ValueMetricExtractionProcessor 

type ValueMetricExtractionProcessor struct {
	Processor
	Dimensions []string `json:"dimensions,omitempty"`
	Field      string   `json:"field"`
	MetricKey  string   `json:"metricKey"`
}

func (*ValueMetricExtractionProcessor) MarshalHCL 

func (p *ValueMetricExtractionProcessor) MarshalHCL(properties hcl.Properties) error

func (ValueMetricExtractionProcessor) MarshalJSON 

func (ep ValueMetricExtractionProcessor) MarshalJSON() ([]byte, error)

func (*ValueMetricExtractionProcessor) Schema 

func (p *ValueMetricExtractionProcessor) Schema() map[string]*schema.Schema

func (*ValueMetricExtractionProcessor) UnmarshalHCL 

func (p *ValueMetricExtractionProcessor) UnmarshalHCL(decoder hcl.Decoder) error

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.