rumweb

package
v1.57.2 Latest Latest
Warning

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

 Go to latest Published: May 21, 2024 License: Apache-2.0 Imports: 2 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var DetectionModes = struct {
	Auto  DetectionMode
	Fixed DetectionMode
}{
	"Auto",
	"Fixed",
}
View Source 
var Sensitivities = struct {
	High   Sensitivity
	Low    Sensitivity
	Medium Sensitivity
}{
	"High",
	"Low",
	"Medium",
}

Functions

This section is empty.

Types

type AppTrafficDrops 

type AppTrafficDrops struct {
	Enabled      bool          `json:"enabled"`                // This setting is enabled (`true`) or disabled (`false`)
	TrafficDrops *TrafficDrops `json:"trafficDrops,omitempty"` // Dynatrace learns your typical application traffic over an observation period of one week.\n\nDepending on this expected value Dynatrace detects abnormal traffic drops within your application.
}

func (*AppTrafficDrops) MarshalHCL 

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

func (*AppTrafficDrops) Schema 

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

func (*AppTrafficDrops) UnmarshalHCL 

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

type AppTrafficSpikes 

type AppTrafficSpikes struct {
	Enabled       bool           `json:"enabled"`                 // This setting is enabled (`true`) or disabled (`false`)
	TrafficSpikes *TrafficSpikes `json:"trafficSpikes,omitempty"` // Dynatrace learns your typical application traffic over an observation period of one week.\n\nDepending on this expected value Dynatrace detects abnormal traffic spikes within your application.
}

func (*AppTrafficSpikes) MarshalHCL 

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

func (*AppTrafficSpikes) Schema 

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

func (*AppTrafficSpikes) UnmarshalHCL 

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

type DetectionMode 

type DetectionMode string

type ErrorRate 

type ErrorRate struct {
	Enabled                bool            `json:"enabled"`                          // This setting is enabled (`true`) or disabled (`false`)
	ErrorRateAuto          *ErrorRateAuto  `json:"errorRateAuto,omitempty"`          // Alert if the percentage of failing user actions increases by **both** the absolute and relative thresholds:
	ErrorRateDetectionMode *DetectionMode  `json:"errorRateDetectionMode,omitempty"` // Possible Values: `Auto`, `Fixed`
	ErrorRateFixed         *ErrorRateFixed `json:"errorRateFixed,omitempty"`
}

func (*ErrorRate) MarshalHCL 

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

func (*ErrorRate) Schema 

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

func (*ErrorRate) UnmarshalHCL 

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

type ErrorRateAuto 

type ErrorRateAuto struct {
	AbsoluteIncrease       float64                     `json:"absoluteIncrease"`       // Absolute threshold
	OverAlertingProtection *OverAlertingProtectionAuto `json:"overAlertingProtection"` // Avoid over-alerting
	RelativeIncrease       float64                     `json:"relativeIncrease"`       // Relative threshold
}

func (*ErrorRateAuto) MarshalHCL 

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

func (*ErrorRateAuto) Schema 

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

func (*ErrorRateAuto) UnmarshalHCL 

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

type ErrorRateFixed 

type ErrorRateFixed struct {
	ErrorRateReqPerMin     float64     `json:"errorRateReqPerMin"`     // To avoid over-alerting for low traffic applications
	ErrorRateSensitivity   Sensitivity `json:"errorRateSensitivity"`   // Possible Values: `Low`, `Medium`, `High`
	MaxFailureRateIncrease float64     `json:"maxFailureRateIncrease"` // Alert if this custom error rate threshold is exceeded during any 5-minute-period
	MinutesAbnormalState   float64     `json:"minutesAbnormalState"`   // Amount of minutes the observed traffic has to stay in abnormal state before alert
}

func (*ErrorRateFixed) MarshalHCL 

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

func (*ErrorRateFixed) Schema 

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

func (*ErrorRateFixed) UnmarshalHCL 

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

type OverAlertingProtectionAuto 

type OverAlertingProtectionAuto struct {
	ActionsPerMinute     float64 `json:"actionsPerMinute"`     // Only alert if there are at least
	MinutesAbnormalState float64 `json:"minutesAbnormalState"` // Only alert if the abnormal state remains for at least
}

func (*OverAlertingProtectionAuto) MarshalHCL 

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

func (*OverAlertingProtectionAuto) Schema 

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

func (*OverAlertingProtectionAuto) UnmarshalHCL 

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

type ResponseTime 

type ResponseTime struct {
	DetectionMode     *DetectionMode     `json:"detectionMode,omitempty"` // Possible Values: `Auto`, `Fixed`
	Enabled           bool               `json:"enabled"`                 // This setting is enabled (`true`) or disabled (`false`)
	ResponseTimeAuto  *ResponseTimeAuto  `json:"responseTimeAuto,omitempty"`
	ResponseTimeFixed *ResponseTimeFixed `json:"responseTimeFixed,omitempty"`
}

func (*ResponseTime) MarshalHCL 

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

func (*ResponseTime) Schema 

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

func (*ResponseTime) UnmarshalHCL 

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

type ResponseTimeAuto 

type ResponseTimeAuto struct {
	OverAlertingProtection *OverAlertingProtectionAuto `json:"overAlertingProtection"` // Avoid over-alerting
	ResponseTimeAll        *ResponseTimeAutoAll        `json:"responseTimeAll"`        // Alert if the median response time of all user actions degrades beyond **both** the absolute and relative thresholds:
	ResponseTimeSlowest    *ResponseTimeAutoSlowest    `json:"responseTimeSlowest"`    // Alert if the response time of the slowest 10% of requests degrades beyond **both** the absolute and relative thresholds:
}

func (*ResponseTimeAuto) MarshalHCL 

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

func (*ResponseTimeAuto) Schema 

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

func (*ResponseTimeAuto) UnmarshalHCL 

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

type ResponseTimeAutoAll 

type ResponseTimeAutoAll struct {
	DegradationMilliseconds float64 `json:"degradationMilliseconds"` // Absolute threshold
	DegradationPercent      float64 `json:"degradationPercent"`      // Relative threshold
}

func (*ResponseTimeAutoAll) MarshalHCL 

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

func (*ResponseTimeAutoAll) Schema 

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

func (*ResponseTimeAutoAll) UnmarshalHCL 

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

type ResponseTimeAutoSlowest 

type ResponseTimeAutoSlowest struct {
	SlowestDegradationMilliseconds float64 `json:"slowestDegradationMilliseconds"` // Absolute threshold
	SlowestDegradationPercent      float64 `json:"slowestDegradationPercent"`      // Relative threshold
}

func (*ResponseTimeAutoSlowest) MarshalHCL 

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

func (*ResponseTimeAutoSlowest) Schema 

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

func (*ResponseTimeAutoSlowest) UnmarshalHCL 

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

type ResponseTimeFixed 

type ResponseTimeFixed struct {
	OverAlertingProtection *OverAlertingProtectionAuto `json:"overAlertingProtection"` // Avoid over-alerting
	ResponseTimeAll        *ResponseTimeFixedAll       `json:"responseTimeAll"`        // Alert if the key performance metric of all requests degrades beyond this threshold:
	ResponseTimeSlowest    *ResponseTimeFixedSlowest   `json:"responseTimeSlowest"`    // Alert if the key performance metric of the slowest 10% of requests degrades beyond this threshold:
	Sensitivity            Sensitivity                 `json:"sensitivity"`            // Possible Values: `Medium`, `High`, `Low`
}

func (*ResponseTimeFixed) MarshalHCL 

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

func (*ResponseTimeFixed) Schema 

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

func (*ResponseTimeFixed) UnmarshalHCL 

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

type ResponseTimeFixedAll 

type ResponseTimeFixedAll struct {
	DegradationMilliseconds float64 `json:"degradationMilliseconds"` // Alert if the key performance metric degrades beyond this many ms within an observation period of 5 minutes
}

func (*ResponseTimeFixedAll) MarshalHCL 

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

func (*ResponseTimeFixedAll) Schema 

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

func (*ResponseTimeFixedAll) UnmarshalHCL 

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

type ResponseTimeFixedSlowest 

type ResponseTimeFixedSlowest struct {
	SlowestDegradationMilliseconds float64 `json:"slowestDegradationMilliseconds"` // Alert if the key performance metric of the slowest 10% degrades beyond this many ms within an observation period of 5 minutes
}

func (*ResponseTimeFixedSlowest) MarshalHCL 

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

func (*ResponseTimeFixedSlowest) Schema 

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

func (*ResponseTimeFixedSlowest) UnmarshalHCL 

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

type Sensitivity 

type Sensitivity string

type Settings 

type Settings struct {
	ErrorRate     *ErrorRate        `json:"errorRate"`       // Error rate
	ResponseTime  *ResponseTime     `json:"responseTime"`    // Response time
	Scope         *string           `json:"-" scope:"scope"` // The scope of this setting (APPLICATION_METHOD, APPLICATION). Omit this property if you want to cover the whole environment.
	TrafficDrops  *AppTrafficDrops  `json:"trafficDrops"`    // Detect traffic drops
	TrafficSpikes *AppTrafficSpikes `json:"trafficSpikes"`   // Detect traffic spikes
}

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 TrafficDrops 

type TrafficDrops struct {
	AbnormalStateAbnormalState float64 `json:"abnormalStateAbnormalState"` // Minutes the observed traffic has to stay in abnormal state before alert
	TrafficDropPercentage      float64 `json:"trafficDropPercentage"`      // Alert if the observed traffic is less than this percentage of the expected value
}

func (*TrafficDrops) MarshalHCL 

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

func (*TrafficDrops) Schema 

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

func (*TrafficDrops) UnmarshalHCL 

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

type TrafficSpikes 

type TrafficSpikes struct {
	MinutesAbnormalState   float64 `json:"minutesAbnormalState"`   // Minutes an application has to stay in abnormal state before alert
	TrafficSpikePercentage float64 `json:"trafficSpikePercentage"` // Alert if the observed traffic is more than this percentage of the expected value
}

func (*TrafficSpikes) MarshalHCL 

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

func (*TrafficSpikes) Schema 

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

func (*TrafficSpikes) UnmarshalHCL 

func (me *TrafficSpikes) 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.