hosts

package
v1.46.0 Latest Latest
Warning

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

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

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var ConnectionLostDetectionSensitivities = struct {
	AlertOnGracefulShutdown     ConnectionLostDetectionSensitivity
	DontAlertOnGracefulShutdown ConnectionLostDetectionSensitivity
}{
	ConnectionLostDetectionSensitivity("ALERT_ON_GRACEFUL_SHUTDOWN"),
	ConnectionLostDetectionSensitivity("DONT_ALERT_ON_GRACEFUL_SHUTDOWN"),
}
View Source 
var DetectionModes = struct {
	Auto   DetectionMode
	Custom DetectionMode
}{
	DetectionMode("auto"),
	DetectionMode("custom"),
}

Functions

This section is empty.

Types

type ConnectionLostDetection 

type ConnectionLostDetection struct {
	Enabled             bool                                `json:"enabled"`                       // Detect host or monitoring connection lost problems
	OnGracefulShutdowns *ConnectionLostDetectionSensitivity `json:"onGracefulShutdowns,omitempty"` // Graceful host shutdowns
}

func (*ConnectionLostDetection) MarshalHCL 

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

func (*ConnectionLostDetection) Schema 

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

func (*ConnectionLostDetection) UnmarshalHCL 

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

type ConnectionLostDetectionSensitivity 

type ConnectionLostDetectionSensitivity string

type DetectionMode 

type DetectionMode string

type EventThresholds 

type EventThresholds struct {
	DealertingEvaluationWindow int `json:"dealertingEvaluationWindow"` // The number of **10-second samples** that form the sliding evaluation window for dealerting.
	DealertingSamples          int `json:"dealertingSamples"`          // The number of **10-second samples** within the evaluation window that must be lower the threshold to close an event
	ViolatingEvaluationWindow  int `json:"violatingEvaluationWindow"`  // The number of **10-second samples** that form the sliding evaluation window to detect violating samples.
	ViolatingSamples           int `json:"violatingSamples"`           // The number of **10-second samples** within the evaluation window that must exceed the threshold to trigger an event
}

func (*EventThresholds) MarshalHCL 

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

func (*EventThresholds) Schema 

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

func (*EventThresholds) UnmarshalHCL 

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

type HighCpuSaturationDetection 

type HighCpuSaturationDetection struct {
	CustomThresholds *HighCpuSaturationDetectionThresholds `json:"customThresholds,omitempty"`
	DetectionMode    *DetectionMode                        `json:"detectionMode,omitempty"` // Detection mode for CPU saturation
	Enabled          bool                                  `json:"enabled"`                 // Detect CPU saturation on host
}

func (*HighCpuSaturationDetection) MarshalHCL 

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

func (*HighCpuSaturationDetection) Schema 

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

func (*HighCpuSaturationDetection) UnmarshalHCL 

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

type HighCpuSaturationDetectionThresholds 

type HighCpuSaturationDetectionThresholds struct {
	CpuSaturation   int              `json:"cpuSaturation"` // Alert if the CPU usage is higher than this threshold for the defined amount of samples
	EventThresholds *EventThresholds `json:"eventThresholds"`
}

func (*HighCpuSaturationDetectionThresholds) MarshalHCL 

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

func (*HighCpuSaturationDetectionThresholds) Schema 

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

func (*HighCpuSaturationDetectionThresholds) UnmarshalHCL 

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

type HighGcActivityDetection 

type HighGcActivityDetection struct {
	CustomThresholds *HighGcActivityDetectionThresholds `json:"customThresholds,omitempty"` // Alert if the GC time **or** the GC suspension is exceeded
	DetectionMode    *DetectionMode                     `json:"detectionMode,omitempty"`    // Detection mode for high GC activity
	Enabled          bool                               `json:"enabled"`                    // You may also configure high GC activity alerting for .NET processes on [extensions events page](/#settings/anomalydetection/extensionevents).
}

func (*HighGcActivityDetection) MarshalHCL 

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

func (*HighGcActivityDetection) Schema 

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

func (*HighGcActivityDetection) UnmarshalHCL 

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

type HighGcActivityDetectionThresholds 

type HighGcActivityDetectionThresholds struct {
	EventThresholds        *EventThresholds `json:"eventThresholds"`
	GcSuspensionPercentage int              `json:"gcSuspensionPercentage"` // Alert if the GC suspension is higher than this threshold
	GcTimePercentage       int              `json:"gcTimePercentage"`       // Alert if GC time is higher than this threshold
}

func (*HighGcActivityDetectionThresholds) MarshalHCL 

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

func (*HighGcActivityDetectionThresholds) Schema 

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

func (*HighGcActivityDetectionThresholds) UnmarshalHCL 

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

type HighMemoryDetection 

type HighMemoryDetection struct {
	CustomThresholds *HighMemoryDetectionThresholds `json:"customThresholds,omitempty"` // Alert if **both** the memory usage and the memory page fault rate thresholds are exceeded on Windows or on Unix systems
	DetectionMode    *DetectionMode                 `json:"detectionMode,omitempty"`    // Detection mode for high memory usage
	Enabled          bool                           `json:"enabled"`                    // Detect high memory usage on host
}

func (*HighMemoryDetection) MarshalHCL 

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

func (*HighMemoryDetection) Schema 

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

func (*HighMemoryDetection) UnmarshalHCL 

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

type HighMemoryDetectionThresholds 

type HighMemoryDetectionThresholds struct {
	EventThresholds                *EventThresholds `json:"eventThresholds"`
	PageFaultsPerSecondNonWindows  int              `json:"pageFaultsPerSecondNonWindows"`  // Alert if the memory page fault rate on Unix systems is higher than this threshold for the defined amount of samples
	PageFaultsPerSecondWindows     int              `json:"pageFaultsPerSecondWindows"`     // Alert if the memory page fault rate on Windows is higher than this threshold for the defined amount of samples
	UsedMemoryPercentageNonWindows int              `json:"usedMemoryPercentageNonWindows"` // Alert if the memory usage on Unix systems is higher than this threshold
	UsedMemoryPercentageWindows    int              `json:"usedMemoryPercentageWindows"`    // Alert if the memory usage on Windows is higher than this threshold
}

func (*HighMemoryDetectionThresholds) MarshalHCL 

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

func (*HighMemoryDetectionThresholds) Schema 

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

func (*HighMemoryDetectionThresholds) UnmarshalHCL 

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

type HighNetworkDetection 

type HighNetworkDetection struct {
	CustomThresholds *HighNetworkDetectionThresholds `json:"customThresholds,omitempty"`
	DetectionMode    *DetectionMode                  `json:"detectionMode,omitempty"` // Detection mode for high network utilization
	Enabled          bool                            `json:"enabled"`                 // Detect high network utilization
}

func (*HighNetworkDetection) MarshalHCL 

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

func (*HighNetworkDetection) Schema 

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

func (*HighNetworkDetection) UnmarshalHCL 

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

type HighNetworkDetectionThresholds 

type HighNetworkDetectionThresholds struct {
	ErrorsPercentage int              `json:"errorsPercentage"` // Alert if sent/received traffic utilization is higher than this threshold for the defined amount of samples
	EventThresholds  *EventThresholds `json:"eventThresholds"`
}

func (*HighNetworkDetectionThresholds) MarshalHCL 

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

func (*HighNetworkDetectionThresholds) Schema 

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

func (*HighNetworkDetectionThresholds) UnmarshalHCL 

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

type HighSystemLoadDetection added in v1.22.0 

type HighSystemLoadDetection struct {
	CustomThresholds *HighSystemLoadDetectionThresholds `json:"customThresholds,omitempty"`
	DetectionMode    *DetectionMode                     `json:"detectionMode,omitempty"` // Possible Values: `Auto`, `Custom`
	Enabled          bool                               `json:"enabled"`                 // This setting is enabled (`true`) or disabled (`false`)
}

func (*HighSystemLoadDetection) MarshalHCL added in v1.22.0 

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

func (*HighSystemLoadDetection) Schema added in v1.22.0 

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

func (*HighSystemLoadDetection) UnmarshalHCL added in v1.22.0 

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

type HighSystemLoadDetectionThresholds added in v1.22.0 

type HighSystemLoadDetectionThresholds struct {
	EventThresholds *EventThresholds `json:"eventThresholds"`
	SystemLoad      float64          `json:"systemLoad"` // Alert if the System Load / Logical cpu core is higher than this threshold for the defined amount of samples
}

func (*HighSystemLoadDetectionThresholds) MarshalHCL added in v1.22.0 

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

func (*HighSystemLoadDetectionThresholds) Schema added in v1.22.0 

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

func (*HighSystemLoadDetectionThresholds) UnmarshalHCL added in v1.22.0 

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

type Host 

type Host struct {
	ConnectionLostDetection    *ConnectionLostDetection    `json:"connectionLostDetection"`
	HighCpuSaturationDetection *HighCpuSaturationDetection `json:"highCpuSaturationDetection"`
	HighGcActivityDetection    *HighGcActivityDetection    `json:"highGcActivityDetection"`
	HighMemoryDetection        *HighMemoryDetection        `json:"highMemoryDetection"`
	HighSystemLoadDetection    *HighSystemLoadDetection    `json:"highSystemLoadDetection"`
	OutOfMemoryDetection       *OutOfMemoryDetection       `json:"outOfMemoryDetection"`
	OutOfThreadsDetection      *OutOfThreadsDetection      `json:"outOfThreadsDetection"`
}

func (*Host) MarshalHCL 

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

func (*Host) Schema 

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

func (*Host) UnmarshalHCL 

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

type Network 

type Network struct {
	HighNetworkDetection               *HighNetworkDetection               `json:"highNetworkDetection"`
	NetworkDroppedPacketsDetection     *NetworkDroppedPacketsDetection     `json:"networkDroppedPacketsDetection"`
	NetworkErrorsDetection             *NetworkErrorsDetection             `json:"networkErrorsDetection"`
	NetworkHighRetransmissionDetection *NetworkHighRetransmissionDetection `json:"networkHighRetransmissionDetection"`
	NetworkTcpProblemsDetection        *NetworkTcpProblemsDetection        `json:"networkTcpProblemsDetection"`
}

func (*Network) MarshalHCL 

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

func (*Network) Schema 

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

func (*Network) UnmarshalHCL 

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

type NetworkDroppedPacketsDetection 

type NetworkDroppedPacketsDetection struct {
	CustomThresholds *NetworkDroppedPacketsDetectionThresholds `json:"customThresholds,omitempty"` // Alert if the dropped packet percentage is higher than the specified threshold **and** the total packets rate is higher than the defined threshold for the defined amount of samples
	DetectionMode    *DetectionMode                            `json:"detectionMode,omitempty"`    // Detection mode for high number of dropped packets
	Enabled          bool                                      `json:"enabled"`                    // Detect high number of dropped packets
}

func (*NetworkDroppedPacketsDetection) MarshalHCL 

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

func (*NetworkDroppedPacketsDetection) Schema 

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

func (*NetworkDroppedPacketsDetection) UnmarshalHCL 

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

type NetworkDroppedPacketsDetectionThresholds 

type NetworkDroppedPacketsDetectionThresholds struct {
	DroppedPacketsPercentage int              `json:"droppedPacketsPercentage"` // Receive/transmit dropped packet percentage threshold
	EventThresholds          *EventThresholds `json:"eventThresholds"`
	TotalPacketsRate         int              `json:"totalPacketsRate"` // Total packets rate threshold
}

func (*NetworkDroppedPacketsDetectionThresholds) MarshalHCL 

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

func (*NetworkDroppedPacketsDetectionThresholds) Schema 

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

func (*NetworkDroppedPacketsDetectionThresholds) UnmarshalHCL 

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

type NetworkErrorsDetection 

type NetworkErrorsDetection struct {
	CustomThresholds *NetworkErrorsDetectionThresholds `json:"customThresholds,omitempty"` // Alert if the receive/transmit error packet percentage is higher than the specified threshold **and** the total packets rate is higher than the defined threshold for the defined amount of samples
	DetectionMode    *DetectionMode                    `json:"detectionMode,omitempty"`    // Detection mode for high number of network errors
	Enabled          bool                              `json:"enabled"`                    // Detect high number of network errors
}

func (*NetworkErrorsDetection) MarshalHCL 

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

func (*NetworkErrorsDetection) Schema 

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

func (*NetworkErrorsDetection) UnmarshalHCL 

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

type NetworkErrorsDetectionThresholds 

type NetworkErrorsDetectionThresholds struct {
	ErrorsPercentage int              `json:"errorsPercentage"` // Receive/transmit error packet percentage threshold
	EventThresholds  *EventThresholds `json:"eventThresholds"`
	TotalPacketsRate int              `json:"totalPacketsRate"` // Total packets rate threshold
}

func (*NetworkErrorsDetectionThresholds) MarshalHCL 

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

func (*NetworkErrorsDetectionThresholds) Schema 

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

func (*NetworkErrorsDetectionThresholds) UnmarshalHCL 

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

type NetworkHighRetransmissionDetection 

type NetworkHighRetransmissionDetection struct {
	CustomThresholds *NetworkHighRetransmissionDetectionThresholds `json:"customThresholds,omitempty"` // Alert if the retransmission rate is higher than the specified threshold **and** the number of retransmitted packets is higher than the defined threshold for the defined amount of samples
	DetectionMode    *DetectionMode                                `json:"detectionMode,omitempty"`    // Detection mode for high retransmission rate
	Enabled          bool                                          `json:"enabled"`                    // Detect high retransmission rate
}

func (*NetworkHighRetransmissionDetection) MarshalHCL 

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

func (*NetworkHighRetransmissionDetection) Schema 

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

func (*NetworkHighRetransmissionDetection) UnmarshalHCL 

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

type NetworkHighRetransmissionDetectionThresholds 

type NetworkHighRetransmissionDetectionThresholds struct {
	EventThresholds                     *EventThresholds `json:"eventThresholds"`
	RetransmissionRatePercentage        int              `json:"retransmissionRatePercentage"`        // Retransmission rate threshold
	RetransmittedPacketsNumberPerMinute int              `json:"retransmittedPacketsNumberPerMinute"` // Number of retransmitted packets threshold
}

func (*NetworkHighRetransmissionDetectionThresholds) MarshalHCL 

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

func (*NetworkHighRetransmissionDetectionThresholds) Schema 

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

func (*NetworkHighRetransmissionDetectionThresholds) UnmarshalHCL 

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

type NetworkTcpProblemsDetection 

type NetworkTcpProblemsDetection struct {
	CustomThresholds *NetworkTcpProblemsDetectionThresholds `json:"customThresholds,omitempty"` // Alert if the percentage of new connection failures is higher than the specified threshold **and** the number of failed connections is higher than the defined threshold for the defined amount of samples
	DetectionMode    *DetectionMode                         `json:"detectionMode,omitempty"`    // Detection mode for TCP connectivity problems
	Enabled          bool                                   `json:"enabled"`                    // Detect TCP connectivity problems for process
}

func (*NetworkTcpProblemsDetection) MarshalHCL 

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

func (*NetworkTcpProblemsDetection) Schema 

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

func (*NetworkTcpProblemsDetection) UnmarshalHCL 

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

type NetworkTcpProblemsDetectionThresholds 

type NetworkTcpProblemsDetectionThresholds struct {
	EventThresholds                  *EventThresholds `json:"eventThresholds"`
	FailedConnectionsNumberPerMinute int              `json:"failedConnectionsNumberPerMinute"` // Number of failed connections threshold
	NewConnectionFailuresPercentage  int              `json:"newConnectionFailuresPercentage"`  // New connection failure threshold
}

func (*NetworkTcpProblemsDetectionThresholds) MarshalHCL 

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

func (*NetworkTcpProblemsDetectionThresholds) Schema 

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

func (*NetworkTcpProblemsDetectionThresholds) UnmarshalHCL 

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

type OutOfMemoryDetection 

type OutOfMemoryDetection struct {
	CustomThresholds *OutOfMemoryDetectionThresholds `json:"customThresholds,omitempty"`
	DetectionMode    *DetectionMode                  `json:"detectionMode,omitempty"` // Detection mode for Java out of memory problem
	Enabled          bool                            `json:"enabled"`                 // Detect Java out of memory problem
}

func (*OutOfMemoryDetection) MarshalHCL 

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

func (*OutOfMemoryDetection) Schema 

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

func (*OutOfMemoryDetection) UnmarshalHCL 

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

type OutOfMemoryDetectionThresholds 

type OutOfMemoryDetectionThresholds struct {
	EventThresholds             *StrictEventThresholds `json:"eventThresholds"`
	OutOfMemoryExceptionsNumber int                    `json:"outOfMemoryExceptionsNumber"` // Alert if the number of Java out-of-memory exceptions is at least this value
}

func (*OutOfMemoryDetectionThresholds) MarshalHCL 

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

func (*OutOfMemoryDetectionThresholds) Schema 

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

func (*OutOfMemoryDetectionThresholds) UnmarshalHCL 

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

type OutOfThreadsDetection 

type OutOfThreadsDetection struct {
	CustomThresholds *OutOfThreadsDetectionThresholds `json:"customThresholds,omitempty"`
	DetectionMode    *DetectionMode                   `json:"detectionMode,omitempty"` // Detection mode for Java out of threads problem
	Enabled          bool                             `json:"enabled"`                 // Detect Java out of threads problem
}

func (*OutOfThreadsDetection) MarshalHCL 

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

func (*OutOfThreadsDetection) Schema 

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

func (*OutOfThreadsDetection) UnmarshalHCL 

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

type OutOfThreadsDetectionThresholds 

type OutOfThreadsDetectionThresholds struct {
	EventThresholds              *StrictEventThresholds `json:"eventThresholds"`
	OutOfThreadsExceptionsNumber int                    `json:"outOfThreadsExceptionsNumber"` // Alert if the number of Java out-of-threads exceptions is at least this value
}

func (*OutOfThreadsDetectionThresholds) MarshalHCL 

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

func (*OutOfThreadsDetectionThresholds) Schema 

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

func (*OutOfThreadsDetectionThresholds) UnmarshalHCL 

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

type Settings 

type Settings struct {
	Host    *Host    `json:"host"`            // Hosts
	Network *Network `json:"network"`         // Network
	Scope   string   `json:"-" scope:"scope"` // The scope of this setting (HOST HOST_GROUP environment)
}

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 StrictEventThresholds 

type StrictEventThresholds struct {
	DealertingEvaluationWindow int `json:"dealertingEvaluationWindow"` // The number of **10-second samples** that form the sliding evaluation window for dealerting.
	DealertingSamples          int `json:"dealertingSamples"`          // The number of **10-second samples** within the evaluation window that must be lower the threshold to close an event
	ViolatingEvaluationWindow  int `json:"violatingEvaluationWindow"`  // The number of **10-second samples** that form the sliding evaluation window to detect violating samples.
	ViolatingSamples           int `json:"violatingSamples"`           // The number of **10-second samples** within the evaluation window that must exceed the threshold to trigger an event
}

func (*StrictEventThresholds) MarshalHCL 

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

func (*StrictEventThresholds) Schema 

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

func (*StrictEventThresholds) UnmarshalHCL 

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