metricevents

package
v1.46.1 Latest Latest
Warning

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

Go to latest
Published: Nov 8, 2023 License: Apache-2.0 Imports: 4 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source
var Aggregations = struct {
	Avg          Aggregation
	Count        Aggregation
	Max          Aggregation
	Median       Aggregation
	Min          Aggregation
	Percentile90 Aggregation
	Sum          Aggregation
	Value        Aggregation
}{
	"AVG",
	"COUNT",
	"MAX",
	"MEDIAN",
	"MIN",
	"PERCENTILE90",
	"SUM",
	"VALUE",
}
View Source
var AlertConditions = struct {
	Above   AlertCondition
	Below   AlertCondition
	Outside AlertCondition
}{
	"ABOVE",
	"BELOW",
	"OUTSIDE",
}
View Source
var DimensionFilterOperators = struct {
	ContainsCaseSensitive       DimensionFilterOperator
	DoesNotContainCaseSensitive DimensionFilterOperator
	DoesNotEqual                DimensionFilterOperator
	DoesNotStartWith            DimensionFilterOperator
	Equals                      DimensionFilterOperator
	StartsWith                  DimensionFilterOperator
}{
	"CONTAINS_CASE_SENSITIVE",
	"DOES_NOT_CONTAIN_CASE_SENSITIVE",
	"DOES_NOT_EQUAL",
	"DOES_NOT_START_WITH",
	"EQUALS",
	"STARTS_WITH",
}
View Source
var EntityFilterOperators = struct {
	ContainsCaseInsensitive       EntityFilterOperator
	ContainsCaseSensitive         EntityFilterOperator
	DoesNotContainCaseInsensitive EntityFilterOperator
	DoesNotContainCaseSensitive   EntityFilterOperator
	DoesNotEqual                  EntityFilterOperator
	DoesNotStartWith              EntityFilterOperator
	Equals                        EntityFilterOperator
	StartsWith                    EntityFilterOperator
}{
	"CONTAINS_CASE_INSENSITIVE",
	"CONTAINS_CASE_SENSITIVE",
	"DOES_NOT_CONTAIN_CASE_INSENSITIVE",
	"DOES_NOT_CONTAIN_CASE_SENSITIVE",
	"DOES_NOT_EQUAL",
	"DOES_NOT_START_WITH",
	"EQUALS",
	"STARTS_WITH",
}
View Source
var EntityFilterTypes = struct {
	CustomDeviceGroupName EntityFilterType
	EntityId              EntityFilterType
	HostGroupName         EntityFilterType
	HostName              EntityFilterType
	ManagementZone        EntityFilterType
	Name                  EntityFilterType
	ProcessGroupId        EntityFilterType
	ProcessGroupName      EntityFilterType
	Tag                   EntityFilterType
}{
	"CUSTOM_DEVICE_GROUP_NAME",
	"ENTITY_ID",
	"HOST_GROUP_NAME",
	"HOST_NAME",
	"MANAGEMENT_ZONE",
	"NAME",
	"PROCESS_GROUP_ID",
	"PROCESS_GROUP_NAME",
	"TAG",
}
View Source
var EventTypeEnums = struct {
	Availability         EventTypeEnum
	CustomAlert          EventTypeEnum
	CustomAnnotation     EventTypeEnum
	CustomConfiguration  EventTypeEnum
	CustomDeployment     EventTypeEnum
	Error                EventTypeEnum
	Info                 EventTypeEnum
	MarkedForTermination EventTypeEnum
	Resource             EventTypeEnum
	Slowdown             EventTypeEnum
}{
	"AVAILABILITY",
	"CUSTOM_ALERT",
	"CUSTOM_ANNOTATION",
	"CUSTOM_CONFIGURATION",
	"CUSTOM_DEPLOYMENT",
	"ERROR",
	"INFO",
	"MARKED_FOR_TERMINATION",
	"RESOURCE",
	"SLOWDOWN",
}
View Source
var ModelTypes = struct {
	AutoAdaptiveThreshold ModelType
	SeasonalBaseline      ModelType
	StaticThreshold       ModelType
}{
	"AUTO_ADAPTIVE_THRESHOLD",
	"SEASONAL_BASELINE",
	"STATIC_THRESHOLD",
}
View Source
var Types = struct {
	MetricKey      Type
	MetricSelector Type
}{
	"METRIC_KEY",
	"METRIC_SELECTOR",
}

Functions

This section is empty.

Types

type Aggregation

type Aggregation string

type AlertCondition

type AlertCondition string

type DimensionFilter

type DimensionFilter struct {
	DimensionKey   string                   `json:"dimensionKey"`       // Dimension key
	DimensionValue string                   `json:"dimensionValue"`     // Dimension value
	Operator       *DimensionFilterOperator `json:"operator,omitempty"` // Possible Values: `CONTAINS_CASE_SENSITIVE`, `DOES_NOT_CONTAIN_CASE_SENSITIVE`, `DOES_NOT_EQUAL`, `DOES_NOT_START_WITH`, `EQUALS`, `STARTS_WITH`
}

func (*DimensionFilter) MarshalHCL

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

func (*DimensionFilter) Schema

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

func (*DimensionFilter) UnmarshalHCL

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

type DimensionFilterOperator

type DimensionFilterOperator string

type DimensionFilters

type DimensionFilters []*DimensionFilter

func (DimensionFilters) MarshalHCL

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

func (*DimensionFilters) Schema

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

func (*DimensionFilters) UnmarshalHCL

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

type EntityFilter

type EntityFilter struct {
	Conditions   EntityFilterConditions `json:"conditions,omitempty"`
	DimensionKey *string                `json:"dimensionKey,omitempty"` // Dimension key of entity type to filter
}

func (*EntityFilter) MarshalHCL

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

func (*EntityFilter) Schema

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

func (*EntityFilter) UnmarshalHCL

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

type EntityFilterCondition

type EntityFilterCondition struct {
	Operator EntityFilterOperator `json:"operator"` // Possible Values: `CONTAINS_CASE_INSENSITIVE`, `CONTAINS_CASE_SENSITIVE`, `DOES_NOT_CONTAIN_CASE_INSENSITIVE`, `DOES_NOT_CONTAIN_CASE_SENSITIVE`, `DOES_NOT_EQUAL`, `DOES_NOT_START_WITH`, `EQUALS`, `STARTS_WITH`
	Type     EntityFilterType     `json:"type"`     // Possible Values: `CUSTOM_DEVICE_GROUP_NAME`, `ENTITY_ID`, `HOST_GROUP_NAME`, `HOST_NAME`, `MANAGEMENT_ZONE`, `NAME`, `PROCESS_GROUP_ID`, `PROCESS_GROUP_NAME`, `TAG`
	Value    string               `json:"value"`
}

func (*EntityFilterCondition) MarshalHCL

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

func (*EntityFilterCondition) Schema

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

func (*EntityFilterCondition) UnmarshalHCL

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

type EntityFilterConditions

type EntityFilterConditions []*EntityFilterCondition

func (EntityFilterConditions) MarshalHCL

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

func (*EntityFilterConditions) Schema

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

func (*EntityFilterConditions) UnmarshalHCL

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

type EntityFilterOperator

type EntityFilterOperator string

type EntityFilterType

type EntityFilterType string

type EventTemplate

type EventTemplate struct {
	DavisMerge  *bool           `json:"davisMerge,omitempty"` // Davis® AI will try to merge this event into existing problems, otherwise a new problem will always be created.
	Description string          `json:"description"`          // The description of the event to trigger.
	EventType   EventTypeEnum   `json:"eventType"`            // Possible Values: `AVAILABILITY`, `CUSTOM_ALERT`, `CUSTOM_ANNOTATION`, `CUSTOM_CONFIGURATION`, `CUSTOM_DEPLOYMENT`, `ERROR`, `INFO`, `MARKED_FOR_TERMINATION`, `RESOURCE`, `SLOWDOWN`
	Metadata    []*MetadataItem `json:"metadata,omitempty"`   // Set of additional key-value properties to be attached to the triggered event.
	Title       string          `json:"title"`                // The title of the event to trigger.
}

func (*EventTemplate) HandlePreconditions

func (me *EventTemplate) HandlePreconditions() error

func (*EventTemplate) MarshalHCL

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

func (*EventTemplate) Schema

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

func (*EventTemplate) UnmarshalHCL

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

type EventTypeEnum

type EventTypeEnum string

type MetadataItem

type MetadataItem struct {
	MetadataKey   string `json:"metadataKey"` // Type 'dt.' for key hints.
	MetadataValue string `json:"metadataValue"`
}

func (*MetadataItem) MarshalHCL

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

func (*MetadataItem) Schema

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

func (*MetadataItem) UnmarshalHCL

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

type MetadataItems

type MetadataItems []*MetadataItem

func (MetadataItems) MarshalHCL

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

func (*MetadataItems) Schema

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

func (*MetadataItems) UnmarshalHCL

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

type ModelProperties

type ModelProperties struct {
	AlertCondition    AlertCondition `json:"alertCondition"`              // Possible Values: `ABOVE`, `BELOW`, `OUTSIDE`
	AlertOnNoData     bool           `json:"alertOnNoData"`               // The ability to set an alert on missing data in a metric. When enabled, missing data samples will contribute as violating samples defined in advanced model properties. We recommend to not alert on missing data for sparse timeseries as this leads to alert spam.
	DealertingSamples int            `json:"dealertingSamples"`           // The number of one-minute samples within the evaluation window that must go back to normal to close the event.
	Samples           int            `json:"samples"`                     // The number of one-minute samples that form the sliding evaluation window.
	SignalFluctuation *float64       `json:"signalFluctuation,omitempty"` // Controls how many times the signal fluctuation is added to the baseline to produce the actual threshold for alerting
	Threshold         *float64       `json:"threshold,omitempty"`         // Raise an event if this value is violated
	Tolerance         *float64       `json:"tolerance,omitempty"`         // Controls the width of the confidence band and larger values lead to a less sensitive model
	Type              ModelType      `json:"type"`                        // Possible Values: `AUTO_ADAPTIVE_THRESHOLD`, `SEASONAL_BASELINE`, `STATIC_THRESHOLD`
	ViolatingSamples  int            `json:"violatingSamples"`            // The number of one-minute samples within the evaluation window that must violate to trigger an event.
}

func (*ModelProperties) HandlePreconditions

func (me *ModelProperties) HandlePreconditions() error

func (*ModelProperties) MarshalHCL

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

func (*ModelProperties) Schema

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

func (*ModelProperties) UnmarshalHCL

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

type ModelType

type ModelType string

type QueryDefinition

type QueryDefinition struct {
	Aggregation     *Aggregation     `json:"aggregation,omitempty"`     // Possible Values: `AVG`, `COUNT`, `MAX`, `MEDIAN`, `MIN`, `PERCENTILE90`, `SUM`, `VALUE`
	DimensionFilter DimensionFilters `json:"dimensionFilter,omitempty"` // Dimension filter
	EntityFilter    *EntityFilter    `json:"entityFilter,omitempty"`    // Use rule-based filters to define the scope this event monitors.
	ManagementZone  *string          `json:"managementZone,omitempty"`  // Management zone
	MetricKey       *string          `json:"metricKey,omitempty"`       // Metric key
	MetricSelector  *string          `json:"metricSelector,omitempty"`  // To learn more, visit [Metric Selector](https://dt-url.net/metselad)
	QueryOffset     *int             `json:"queryOffset,omitempty"`     // Minute offset of sliding evaluation window for metrics with latency
	Type            Type             `json:"type"`                      // Possible Values: `METRIC_KEY`, `METRIC_SELECTOR`
}

func (*QueryDefinition) HandlePreconditions

func (me *QueryDefinition) HandlePreconditions() error

func (*QueryDefinition) MarshalHCL

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

func (*QueryDefinition) Schema

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

func (*QueryDefinition) UnmarshalHCL

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

type Settings

type Settings struct {
	Enabled                 bool             `json:"enabled"`                           // This setting is enabled (`true`) or disabled (`false`)
	EventEntityDimensionKey *string          `json:"eventEntityDimensionKey,omitempty"` // Controls the preferred entity type used for triggered events.
	EventTemplate           *EventTemplate   `json:"eventTemplate"`                     // Event template
	LegacyID                *string          `json:"legacyId,omitempty"`                // Config id
	ModelProperties         *ModelProperties `json:"modelProperties"`                   // Monitoring strategy
	QueryDefinition         *QueryDefinition `json:"queryDefinition"`                   // Query definition
	Summary                 string           `json:"summary"`                           // The textual summary of the metric event entry
}

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 Type

type Type string

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL