diff --git a/integrations/datadogunifi/README.md b/integrations/datadogunifi/README.md index 4b3cf5ca..a3755288 100644 --- a/integrations/datadogunifi/README.md +++ b/integrations/datadogunifi/README.md @@ -1,3 +1,83 @@ # datadogunifi UniFi Poller Output Plugin for DataDog + +## Configuration + +```yaml +datadog: + # How often to poll UniFi and report to Datadog. + interval: "2m" + + # To disable this output plugin + disable: false + + # Datadog Custom Options + + # address to talk to the datadog agent, by default this uses the local statsd UDP interface + # address: "..." + + # namespace to prepend to all data + # namespace: "" + + # tags to append to all data + # tags: + # - foo + + # max_bytes_per_payload is the maximum number of bytes a single payload will contain. + # The magic value 0 will set the option to the optimal size for the transport + # protocol used when creating the client: 1432 for UDP and 8192 for UDS. + # max_bytes_per_payload: 0 + + # max_messages_per_payload is the maximum number of metrics, events and/or service checks a single payload will contain. + # This option can be set to `1` to create an unbuffered client. + # max_messages_per_payload: 0 + + # BufferPoolSize is the size of the pool of buffers in number of buffers. + # The magic value 0 will set the option to the optimal size for the transport + # protocol used when creating the client: 2048 for UDP and 512 for UDS. + # buffer_pool_size: 0 + + # buffer_flush_interval is the interval after which the current buffer will get flushed. + # buffer_flush_interval: 0 + + # buffer_shard_count is the number of buffer "shards" that will be used. + # Those shards allows the use of multiple buffers at the same time to reduce + # lock contention. + # buffer_shard_count: 0 + + # sender_queue_size is the size of the sender queue in number of buffers. + # The magic value 0 will set the option to the optimal size for the transport + # protocol used when creating the client: 2048 for UDP and 512 for UDS. + # sender_queue_size: 0 + + # write_timeout_uds is the timeout after which a UDS packet is dropped. + # write_timeout_uds: 5000 + + # receive_mode determines the behavior of the client when receiving to many + # metrics. The client will either drop the metrics if its buffers are + # full (ChannelMode mode) or block the caller until the metric can be + # handled (MutexMode mode). By default the client will MutexMode. This + # option should be set to ChannelMode only when use under very high + # load. + # + # MutexMode uses a mutex internally which is much faster than + # channel but causes some lock contention when used with a high number + # of threads. Mutex are sharded based on the metrics name which + # limit mutex contention when goroutines send different metrics. + # + # ChannelMode: uses channel (of ChannelModeBufferSize size) to send + # metrics and drop metrics if the channel is full. Sending metrics in + # this mode is slower that MutexMode (because of the channel), but + # will not block the application. This mode is made for application + # using many goroutines, sending the same metrics at a very high + # volume. The goal is to not slow down the application at the cost of + # dropping metrics and having a lower max throughput. + # receive_mode: 0 + + # channel_mode_buffer_size is the size of the channel holding incoming metrics + # channel_mode_buffer_size: 0 + + # aggregation_flush_interval is the interval for the aggregator to flush metrics + # aggregation_flush_interval: 0 +``` \ No newline at end of file diff --git a/integrations/datadogunifi/datadog.go b/integrations/datadogunifi/datadog.go index 4f9e4be7..377dca26 100644 --- a/integrations/datadogunifi/datadog.go +++ b/integrations/datadogunifi/datadog.go @@ -34,32 +34,41 @@ type Config struct { // Namespace to prepend to all metrics, events and service checks name. Namespace *string `json:"namespace" toml:"namespace" xml:"namespace,attr" yaml:"namespace"` + // Tags are global tags to be applied to every metrics, events and service checks. Tags []string `json:"tags" toml:"tags" xml:"tags,attr" yaml:"tags"` + // MaxBytesPerPayload is the maximum number of bytes a single payload will contain. // The magic value 0 will set the option to the optimal size for the transport // protocol used when creating the client: 1432 for UDP and 8192 for UDS. MaxBytesPerPayload *int `json:"max_bytes_per_payload" toml:"max_bytes_per_payload" xml:"max_bytes_per_payload,attr" yaml:"max_bytes_per_payload"` + // MaxMessagesPerPayload is the maximum number of metrics, events and/or service checks a single payload will contain. // This option can be set to `1` to create an unbuffered client. MaxMessagesPerPayload *int `json:"max_messages_per_payload" toml:"max_messages_per_payload" xml:"max_messages_per_payload,attr" yaml:"max_messages_per_payload"` + // BufferPoolSize is the size of the pool of buffers in number of buffers. // The magic value 0 will set the option to the optimal size for the transport // protocol used when creating the client: 2048 for UDP and 512 for UDS. BufferPoolSize *int `json:"buffer_pool_size" toml:"buffer_pool_size" xml:"buffer_pool_size,attr" yaml:"buffer_pool_size"` + // BufferFlushInterval is the interval after which the current buffer will get flushed. BufferFlushInterval *cnfg.Duration `json:"buffer_flush_interval" toml:"buffer_flush_interval" xml:"buffer_flush_interval,attr" yaml:"buffer_flush_interval"` + // BufferShardCount is the number of buffer "shards" that will be used. // Those shards allows the use of multiple buffers at the same time to reduce // lock contention. BufferShardCount *int `json:"buffer_shard_count" toml:"buffer_shard_count" xml:"buffer_shard_count,attr" yaml:"buffer_shard_count"` + // SenderQueueSize is the size of the sender queue in number of buffers. // The magic value 0 will set the option to the optimal size for the transport // protocol used when creating the client: 2048 for UDP and 512 for UDS. SenderQueueSize *int `json:"sender_queue_size" toml:"sender_queue_size" xml:"sender_queue_size,attr" yaml:"sender_queue_size"` + // WriteTimeoutUDS is the timeout after which a UDS packet is dropped. WriteTimeoutUDS *cnfg.Duration `json:"write_timeout_uds" toml:"write_timeout_uds" xml:"write_timeout_uds,attr" yaml:"write_timeout_uds"` - // ReceiveMode determins the behavior of the client when receiving to many + + // ReceiveMode determines the behavior of the client when receiving to many // metrics. The client will either drop the metrics if its buffers are // full (ChannelMode mode) or block the caller until the metric can be // handled (MutexMode mode). By default the client will MutexMode. This @@ -79,8 +88,10 @@ type Config struct { // volume. The goal is to not slow down the application at the cost of // dropping metrics and having a lower max throughput. ReceiveMode *statsd.ReceivingMode `json:"receive_mode" toml:"receive_mode" xml:"receive_mode,attr" yaml:"receive_mode"` + // ChannelModeBufferSize is the size of the channel holding incoming metrics ChannelModeBufferSize *int `json:"channel_mode_buffer_size" toml:"channel_mode_buffer_size" xml:"channel_mode_buffer_size,attr" yaml:"channel_mode_buffer_size"` + // AggregationFlushInterval is the interval for the aggregator to flush metrics AggregationFlushInterval *time.Duration `json:"aggregation_flush_interval" toml:"aggregation_flush_interval" xml:"aggregation_flush_interval,attr" yaml:"aggregation_flush_interval"` }