relation

Documentation

Index

• Variables
• type IngestDataSource
• type MappingRule
  • func (me *MappingRule) MarshalHCL(properties hcl.Properties) error
  • func (me *MappingRule) Schema() map[string]*schema.Schema
  • func (me *MappingRule) UnmarshalHCL(decoder hcl.Decoder) error
• type MappingRules
  • func (me MappingRules) MarshalHCL(properties hcl.Properties) error
  • func (me *MappingRules) Schema() map[string]*schema.Schema
  • func (me *MappingRules) UnmarshalHCL(decoder hcl.Decoder) error
• type Normalization
• type RelationType
• type Settings
  • func (me *Settings) MarshalHCL(properties hcl.Properties) error
  • func (me *Settings) Name() string
  • func (me *Settings) Schema() map[string]*schema.Schema
  • func (me *Settings) UnmarshalHCL(decoder hcl.Decoder) error
• type SourceFilter
  • func (me *SourceFilter) MarshalHCL(properties hcl.Properties) error
  • func (me *SourceFilter) Schema() map[string]*schema.Schema
  • func (me *SourceFilter) UnmarshalHCL(decoder hcl.Decoder) error
• type SourceFilters
  • func (me SourceFilters) MarshalHCL(properties hcl.Properties) error
  • func (me *SourceFilters) Schema() map[string]*schema.Schema
  • func (me *SourceFilters) UnmarshalHCL(decoder hcl.Decoder) error

Variables

var IngestDataSources = struct {
	Entities IngestDataSource
	Events   IngestDataSource
	Logs     IngestDataSource
	Metrics  IngestDataSource
	Spans    IngestDataSource
	Topology IngestDataSource
}{
	"Entities",
	"Events",
	"Logs",
	"Metrics",
	"Spans",
	"Topology",
}

var Normalizations = struct {
	LeavetextasIs Normalization
	Tolowercase   Normalization
	Touppercase   Normalization
}{
	"Leavetextas_is",
	"Tolowercase",
	"Touppercase",
}

var RelationTypes = struct {
	Calls      RelationType
	ChildOf    RelationType
	InstanceOf RelationType
	PartOf     RelationType
	RunsOn     RelationType
	SameAs     RelationType
}{
	"CALLS",
	"CHILD_OF",
	"INSTANCE_OF",
	"PART_OF",
	"RUNS_ON",
	"SAME_AS",
}

Types

type IngestDataSource

type IngestDataSource string

type MappingRule

type MappingRule struct {
	DestinationProperty       string        `json:"destinationProperty"`       // The case-sensitive name of a property of the destination type.
	DestinationTransformation Normalization `json:"destinationTransformation"` // Possible Values: `Leavetextas_is`, `Tolowercase`, `Touppercase`
	SourceProperty            string        `json:"sourceProperty"`            // The case-sensitive name of a property of the source type.
	SourceTransformation      Normalization `json:"sourceTransformation"`      // Possible Values: `Leavetextas_is`, `Tolowercase`, `Touppercase`
}

func (*MappingRule) MarshalHCL

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

func (*MappingRule) Schema

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

func (*MappingRule) UnmarshalHCL

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

type MappingRules

type MappingRules []*MappingRule

func (MappingRules) MarshalHCL

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

func (*MappingRules) Schema

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

func (*MappingRules) UnmarshalHCL

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

type Normalization

type Normalization string

type RelationType

type RelationType string

type Settings

type Settings struct {
	CreatedBy      string        `json:"createdBy"`          // The user or extension that created this relationship.
	Enabled        bool          `json:"enabled"`            // This setting is enabled (`true`) or disabled (`false`)
	FromRole       *string       `json:"fromRole,omitempty"` // Specify a role for the source entity. If both source and destination type are the same, referring different roles will allow identification of a relationships direction. If role is left blank, any role of the source type is considered for the relationship.
	FromType       string        `json:"fromType"`           // Define an entity type as the source of the relationship.
	Sources        SourceFilters `json:"sources"`            // Specify all sources which should be evaluated for this relationship rule. The relationship is only created when any of the filters match.
	ToRole         *string       `json:"toRole,omitempty"`   // Specify a role for the destination entity. If both source and destination type are the same, referring different roles will allow identification of a relationships direction. If role is left blank, any role of the destination type is considered for the relationship.
	ToType         string        `json:"toType"`             // Define an entity type as the destination of the relationship. You can choose the same type as the source type. In this case you also may assign different roles for source and destination for having directed relationships.
	TypeOfRelation RelationType  `json:"typeOfRelation"`     // Possible Values: `CALLS`, `CHILD_OF`, `INSTANCE_OF`, `PART_OF`, `RUNS_ON`, `SAME_AS`
}

func (*Settings) MarshalHCL

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

func (*Settings) Name

func (me *Settings) Name() string

func (*Settings) Schema

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

func (*Settings) UnmarshalHCL

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

type SourceFilter

type SourceFilter struct {
	Condition    *string          `json:"condition,omitempty"`    // Specify a filter that needs to match in order for the extraction to happen.. Two different filters are supported: `$eq(value)` will ensure that the source matches exactly 'value', while `$prefix(value)` will ensure that the source begins with exactly 'value'.\nIf your value contains the characters '(', ')' or '\\~', you need to escape them by adding a '\\~' in front of them.
	MappingRules MappingRules     `json:"mappingRules,omitempty"` // Specify all properties which should be compared. If all mapping rules match a relationship between entities will be created.
	SourceType   IngestDataSource `json:"sourceType"`             // Possible Values: `Entities`, `Events`, `Logs`, `Metrics`, `Spans`, `Topology`
}

Source filter. The source filter determines based on which data the relationship should be created. This way a subset of a specified data source can be used for creating the type.

func (*SourceFilter) MarshalHCL

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

func (*SourceFilter) Schema

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

func (*SourceFilter) UnmarshalHCL

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

type SourceFilters

type SourceFilters []*SourceFilter

func (SourceFilters) MarshalHCL

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

func (*SourceFilters) Schema

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

func (*SourceFilters) UnmarshalHCL

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