aws

package
v1.49.2 Latest Latest
Warning

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

 Go to latest Published: Feb 9, 2024 License: Apache-2.0 Imports: 3 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var DetectionModes = struct {
	Auto   DetectionMode
	Custom DetectionMode
}{
	"auto",
	"custom",
}

Functions

This section is empty.

Types

type DetectionMode 

type DetectionMode string

type Ec2CandidateHighCpuDetectionConfig 

type Ec2CandidateHighCpuDetectionConfig struct {
	CustomThresholds *Ec2CandidateHighCpuDetectionThresholds `json:"customThresholds,omitempty"` // Alert if the condition is met in 3 out of 5 samples
	DetectionMode    *DetectionMode                          `json:"detectionMode,omitempty"`    // Possible Values: `Auto`, `Custom`
	Enabled          bool                                    `json:"enabled"`                    // This setting is enabled (`true`) or disabled (`false`)
}

func (*Ec2CandidateHighCpuDetectionConfig) HandlePreconditions 

func (me *Ec2CandidateHighCpuDetectionConfig) HandlePreconditions() error

func (*Ec2CandidateHighCpuDetectionConfig) MarshalHCL 

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

func (*Ec2CandidateHighCpuDetectionConfig) Schema 

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

func (*Ec2CandidateHighCpuDetectionConfig) UnmarshalHCL 

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

type Ec2CandidateHighCpuDetectionThresholds 

type Ec2CandidateHighCpuDetectionThresholds struct {
	CpuUsage float64 `json:"cpuUsage"` // CPU usage is higher than
}

Ec2CandidateHighCpuDetectionThresholds. Alert if the condition is met in 3 out of 5 samples

func (*Ec2CandidateHighCpuDetectionThresholds) MarshalHCL 

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

func (*Ec2CandidateHighCpuDetectionThresholds) Schema 

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

func (*Ec2CandidateHighCpuDetectionThresholds) UnmarshalHCL 

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

type ElbHighConnectionErrorsDetectionConfig 

type ElbHighConnectionErrorsDetectionConfig struct {
	CustomThresholds *ElbHighConnectionErrorsDetectionThresholds `json:"customThresholds,omitempty"` // Alert if the condition is met in 3 out of 5 samples
	DetectionMode    *DetectionMode                              `json:"detectionMode,omitempty"`    // Possible Values: `Auto`, `Custom`
	Enabled          bool                                        `json:"enabled"`                    // This setting is enabled (`true`) or disabled (`false`)
}

func (*ElbHighConnectionErrorsDetectionConfig) HandlePreconditions 

func (me *ElbHighConnectionErrorsDetectionConfig) HandlePreconditions() error

func (*ElbHighConnectionErrorsDetectionConfig) MarshalHCL 

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

func (*ElbHighConnectionErrorsDetectionConfig) Schema 

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

func (*ElbHighConnectionErrorsDetectionConfig) UnmarshalHCL 

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

type ElbHighConnectionErrorsDetectionThresholds 

type ElbHighConnectionErrorsDetectionThresholds struct {
	ConnectionErrorsPerMinute int `json:"connectionErrorsPerMinute"` // Number of backend connection errors is higher than
}

ElbHighConnectionErrorsDetectionThresholds. Alert if the condition is met in 3 out of 5 samples

func (*ElbHighConnectionErrorsDetectionThresholds) MarshalHCL 

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

func (*ElbHighConnectionErrorsDetectionThresholds) Schema 

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

func (*ElbHighConnectionErrorsDetectionThresholds) UnmarshalHCL 

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

type LambdaHighErrorRateDetectionConfig 

type LambdaHighErrorRateDetectionConfig struct {
	CustomThresholds *LambdaHighErrorRateDetectionThresholds `json:"customThresholds,omitempty"` // Alert if the condition is met in 3 out of 5 samples
	DetectionMode    *DetectionMode                          `json:"detectionMode,omitempty"`    // Possible Values: `Auto`, `Custom`
	Enabled          bool                                    `json:"enabled"`                    // This setting is enabled (`true`) or disabled (`false`)
}

func (*LambdaHighErrorRateDetectionConfig) HandlePreconditions 

func (me *LambdaHighErrorRateDetectionConfig) HandlePreconditions() error

func (*LambdaHighErrorRateDetectionConfig) MarshalHCL 

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

func (*LambdaHighErrorRateDetectionConfig) Schema 

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

func (*LambdaHighErrorRateDetectionConfig) UnmarshalHCL 

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

type LambdaHighErrorRateDetectionThresholds 

type LambdaHighErrorRateDetectionThresholds struct {
	FailedInvocationsRate int `json:"failedInvocationsRate"` // Failed invocations rate is higher than
}

LambdaHighErrorRateDetectionThresholds. Alert if the condition is met in 3 out of 5 samples

func (*LambdaHighErrorRateDetectionThresholds) MarshalHCL 

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

func (*LambdaHighErrorRateDetectionThresholds) Schema 

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

func (*LambdaHighErrorRateDetectionThresholds) UnmarshalHCL 

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

type RdsHighCpuDetectionConfig 

type RdsHighCpuDetectionConfig struct {
	CustomThresholds *RdsHighCpuDetectionThresholds `json:"customThresholds,omitempty"` // Alert if the condition is met in 3 out of 5 samples
	DetectionMode    *DetectionMode                 `json:"detectionMode,omitempty"`    // Possible Values: `Auto`, `Custom`
	Enabled          bool                           `json:"enabled"`                    // This setting is enabled (`true`) or disabled (`false`)
}

func (*RdsHighCpuDetectionConfig) HandlePreconditions 

func (me *RdsHighCpuDetectionConfig) HandlePreconditions() error

func (*RdsHighCpuDetectionConfig) MarshalHCL 

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

func (*RdsHighCpuDetectionConfig) Schema 

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

func (*RdsHighCpuDetectionConfig) UnmarshalHCL 

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

type RdsHighCpuDetectionThresholds 

type RdsHighCpuDetectionThresholds struct {
	CpuUsage float64 `json:"cpuUsage"` // CPU usage is higher than
}

RdsHighCpuDetectionThresholds. Alert if the condition is met in 3 out of 5 samples

func (*RdsHighCpuDetectionThresholds) MarshalHCL 

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

func (*RdsHighCpuDetectionThresholds) Schema 

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

func (*RdsHighCpuDetectionThresholds) UnmarshalHCL 

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

type RdsHighMemoryDetectionConfig 

type RdsHighMemoryDetectionConfig struct {
	CustomThresholds *RdsHighMemoryDetectionThresholds `json:"customThresholds,omitempty"` // Alert if **both** conditions is met in 3 out of 5 samples
	DetectionMode    *DetectionMode                    `json:"detectionMode,omitempty"`    // Possible Values: `Auto`, `Custom`
	Enabled          bool                              `json:"enabled"`                    // This setting is enabled (`true`) or disabled (`false`)
}

func (*RdsHighMemoryDetectionConfig) HandlePreconditions 

func (me *RdsHighMemoryDetectionConfig) HandlePreconditions() error

func (*RdsHighMemoryDetectionConfig) MarshalHCL 

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

func (*RdsHighMemoryDetectionConfig) Schema 

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

func (*RdsHighMemoryDetectionConfig) UnmarshalHCL 

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

type RdsHighMemoryDetectionThresholds 

type RdsHighMemoryDetectionThresholds struct {
	FreeMemory float64 `json:"freeMemory"` // Freeable memory is lower than
	SwapUsage  float64 `json:"swapUsage"`  // Swap usage is higher than
}

RdsHighMemoryDetectionThresholds. Alert if **both** conditions is met in 3 out of 5 samples

func (*RdsHighMemoryDetectionThresholds) MarshalHCL 

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

func (*RdsHighMemoryDetectionThresholds) Schema 

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

func (*RdsHighMemoryDetectionThresholds) UnmarshalHCL 

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

type RdsHighWriteReadLatencyDetectionConfig 

type RdsHighWriteReadLatencyDetectionConfig struct {
	CustomThresholds *RdsHighWriteReadLatencyDetectionThresholds `json:"customThresholds,omitempty"` // Alert if the condition is met in 3 out of 5 samples
	DetectionMode    *DetectionMode                              `json:"detectionMode,omitempty"`    // Possible Values: `Auto`, `Custom`
	Enabled          bool                                        `json:"enabled"`                    // This setting is enabled (`true`) or disabled (`false`)
}

func (*RdsHighWriteReadLatencyDetectionConfig) HandlePreconditions 

func (me *RdsHighWriteReadLatencyDetectionConfig) HandlePreconditions() error

func (*RdsHighWriteReadLatencyDetectionConfig) MarshalHCL 

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

func (*RdsHighWriteReadLatencyDetectionConfig) Schema 

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

func (*RdsHighWriteReadLatencyDetectionConfig) UnmarshalHCL 

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

type RdsHighWriteReadLatencyDetectionThresholds 

type RdsHighWriteReadLatencyDetectionThresholds struct {
	ReadWriteLatency int `json:"readWriteLatency"` // Read/write latency is higher than
}

RdsHighWriteReadLatencyDetectionThresholds. Alert if the condition is met in 3 out of 5 samples

func (*RdsHighWriteReadLatencyDetectionThresholds) MarshalHCL 

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

func (*RdsHighWriteReadLatencyDetectionThresholds) Schema 

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

func (*RdsHighWriteReadLatencyDetectionThresholds) UnmarshalHCL 

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

type RdsLowStorageDetectionConfig 

type RdsLowStorageDetectionConfig struct {
	CustomThresholds *RdsLowStorageDetectionThresholds `json:"customThresholds,omitempty"` // Alert if the condition is met in 3 out of 5 samples
	DetectionMode    *DetectionMode                    `json:"detectionMode,omitempty"`    // Possible Values: `Auto`, `Custom`
	Enabled          bool                              `json:"enabled"`                    // This setting is enabled (`true`) or disabled (`false`)
}

func (*RdsLowStorageDetectionConfig) HandlePreconditions 

func (me *RdsLowStorageDetectionConfig) HandlePreconditions() error

func (*RdsLowStorageDetectionConfig) MarshalHCL 

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

func (*RdsLowStorageDetectionConfig) Schema 

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

func (*RdsLowStorageDetectionConfig) UnmarshalHCL 

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

type RdsLowStorageDetectionThresholds 

type RdsLowStorageDetectionThresholds struct {
	FreeStoragePercentage int `json:"freeStoragePercentage"` // Free storage space divided by allocated storage is lower than
}

RdsLowStorageDetectionThresholds. Alert if the condition is met in 3 out of 5 samples

func (*RdsLowStorageDetectionThresholds) MarshalHCL 

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

func (*RdsLowStorageDetectionThresholds) Schema 

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

func (*RdsLowStorageDetectionThresholds) UnmarshalHCL 

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

type RdsRestartsSequenceDetectionConfig 

type RdsRestartsSequenceDetectionConfig struct {
	CustomThresholds *RdsRestartsSequenceDetectionThresholds `json:"customThresholds,omitempty"` // Alert if the condition is met in 2 out of 20 samples
	DetectionMode    *DetectionMode                          `json:"detectionMode,omitempty"`    // Possible Values: `Auto`, `Custom`
	Enabled          bool                                    `json:"enabled"`                    // This setting is enabled (`true`) or disabled (`false`)
}

func (*RdsRestartsSequenceDetectionConfig) HandlePreconditions 

func (me *RdsRestartsSequenceDetectionConfig) HandlePreconditions() error

func (*RdsRestartsSequenceDetectionConfig) MarshalHCL 

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

func (*RdsRestartsSequenceDetectionConfig) Schema 

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

func (*RdsRestartsSequenceDetectionConfig) UnmarshalHCL 

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

type RdsRestartsSequenceDetectionThresholds 

type RdsRestartsSequenceDetectionThresholds struct {
	RestartsPerMinute int `json:"restartsPerMinute"` // Number of restarts per minute is equal or higher than
}

RdsRestartsSequenceDetectionThresholds. Alert if the condition is met in 2 out of 20 samples

func (*RdsRestartsSequenceDetectionThresholds) MarshalHCL 

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

func (*RdsRestartsSequenceDetectionThresholds) Schema 

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

func (*RdsRestartsSequenceDetectionThresholds) UnmarshalHCL 

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

type Settings 

type Settings struct {
	Ec2CandidateHighCpuDetection     *Ec2CandidateHighCpuDetectionConfig     `json:"ec2CandidateHighCpuDetection"`
	ElbHighConnectionErrorsDetection *ElbHighConnectionErrorsDetectionConfig `json:"elbHighConnectionErrorsDetection"`
	LambdaHighErrorRateDetection     *LambdaHighErrorRateDetectionConfig     `json:"lambdaHighErrorRateDetection"`
	RdsHighCpuDetection              *RdsHighCpuDetectionConfig              `json:"rdsHighCpuDetection"`
	RdsHighMemoryDetection           *RdsHighMemoryDetectionConfig           `json:"rdsHighMemoryDetection"`
	RdsHighWriteReadLatencyDetection *RdsHighWriteReadLatencyDetectionConfig `json:"rdsHighWriteReadLatencyDetection"`
	RdsLowStorageDetection           *RdsLowStorageDetectionConfig           `json:"rdsLowStorageDetection"`
	RdsRestartsSequenceDetection     *RdsRestartsSequenceDetectionConfig     `json:"rdsRestartsSequenceDetection"`
}

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

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.