mirror of
https://github.com/hanzos3/madmin-go.git
synced 2026-10-30 20:35:32 +00:00
The log_api_internal subsystem gained retention, maintenance_interval, and orphan_grace_period keys, but InternalAPIRecorder only carried enable. As a result GetAPILogConfig dropped the new fields and they were absent from the YAML export (and from set-config round-trips). Co-authored-by: Praveenrajmani <[email protected]>
1178 lines
42 KiB
Go
1178 lines
42 KiB
Go
//
|
|
// Copyright (c) 2015-2025 MinIO, Inc.
|
|
//
|
|
// This file is part of MinIO Object Storage stack
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
//
|
|
|
|
package madmin
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
// Log recorder config key constants (server-side keys are snake_case)
|
|
const (
|
|
logKeyEnable = "enable"
|
|
logKeyDriveLimit = "drive_limit"
|
|
logKeyFlushCount = "flush_count"
|
|
logKeyFlushInterval = "flush_interval"
|
|
logKeyEndpoint = "endpoint"
|
|
logKeyAuthToken = "auth_token"
|
|
logKeyClientCert = "client_cert"
|
|
logKeyClientKey = "client_key"
|
|
logKeyProxy = "proxy"
|
|
logKeyBatchSize = "batch_size"
|
|
logKeyMaxRetry = "max_retry"
|
|
logKeyRetryInterval = "retry_interval"
|
|
logKeyBatchPayloadSize = "batch_payload_size"
|
|
logKeyHTTPTimeout = "http_timeout"
|
|
logKeyTLSSkipVerify = "tls_skip_verify"
|
|
logKeyEncoding = "encoding"
|
|
logKeyBrokers = "brokers"
|
|
logKeyTopic = "topic"
|
|
logKeyVersion = "version"
|
|
logKeyTLS = "tls"
|
|
logKeyTLSClientAuth = "tls_client_auth"
|
|
logKeyClientTLSCert = "client_tls_cert"
|
|
logKeyClientTLSKey = "client_tls_key"
|
|
logKeySASL = "sasl"
|
|
logKeySASLUsername = "sasl_username"
|
|
logKeySASLPassword = "sasl_password"
|
|
logKeySASLMechanism = "sasl_mechanism"
|
|
logKeySASLKrbRealm = "sasl_krb_realm"
|
|
logKeySASLKrbKeytab = "sasl_krb_keytab"
|
|
logKeySASLKrbConfig = "sasl_krb_config_path"
|
|
logKeySASLKrbPrincipal = "sasl_krb_principal"
|
|
logKeyName = "name"
|
|
|
|
// Internal API recorder config keys
|
|
logKeyRetention = "retention"
|
|
logKeyMaintenanceInterval = "maintenance_interval"
|
|
logKeyOrphanGracePeriod = "orphan_grace_period"
|
|
|
|
// Queue config keys
|
|
logKeyDir = "dir"
|
|
logKeyDirMaxSize = "dir_max_size"
|
|
logKeyFlushTimeout = "flush_timeout"
|
|
)
|
|
|
|
// LogField represents a configuration field with its value and description
|
|
type LogField struct {
|
|
Value string `json:"value" yaml:"value"`
|
|
Description string `json:"description,omitempty" yaml:"description,omitempty"`
|
|
}
|
|
|
|
// String returns the value of the field
|
|
func (f LogField) String() string {
|
|
return f.Value
|
|
}
|
|
|
|
// UnmarshalYAML implements custom YAML unmarshalling for LogField.
|
|
// It handles both simple format (enable: off) and full format (enable: {value: off, description: ...})
|
|
func (f *LogField) UnmarshalYAML(node *yaml.Node) error {
|
|
// Try simple scalar value first (e.g., "off", "on", "100")
|
|
if node.Kind == yaml.ScalarNode {
|
|
f.Value = node.Value
|
|
return nil
|
|
}
|
|
|
|
// Try full struct format
|
|
type logFieldAlias LogField
|
|
return node.Decode((*logFieldAlias)(f))
|
|
}
|
|
|
|
// getDescription finds description for a key from Help
|
|
func getDescription(help Help, key string) string {
|
|
for _, kh := range help.KeysHelp {
|
|
if kh.Key == key {
|
|
return kh.Description
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// getLogField creates a LogField from SubsysConfig and Help
|
|
// For keys not in Help (like "name"), it uses custom descriptions
|
|
func getLogField(sc SubsysConfig, help Help, key string) LogField {
|
|
value, _ := sc.Lookup(key)
|
|
description := getDescription(help, key)
|
|
|
|
// Custom descriptions for fields not in HelpConfigKV
|
|
if description == "" {
|
|
switch key {
|
|
case logKeyName:
|
|
description = "name of the target; \"_\" for default; auto-generated as \"target-{i}\" if empty when setting"
|
|
}
|
|
}
|
|
|
|
// The server's GetConfigKV API doesn't return "enable=on" explicitly when
|
|
// a subsystem is enabled. If enable is empty, default to "on" since the
|
|
// config exists (meaning the subsystem is configured/enabled).
|
|
if key == logKeyEnable && value == "" {
|
|
value = "on"
|
|
}
|
|
|
|
return LogField{
|
|
Value: value,
|
|
Description: description,
|
|
}
|
|
}
|
|
|
|
// InternalRecorder represents common internal recorder config fields
|
|
type InternalRecorder struct {
|
|
Enable LogField `json:"enable" yaml:"enable"`
|
|
DriveLimit LogField `json:"driveLimit" yaml:"driveLimit"`
|
|
FlushCount LogField `json:"flushCount" yaml:"flushCount"`
|
|
FlushInterval LogField `json:"flushInterval" yaml:"flushInterval"`
|
|
}
|
|
|
|
// InternalAPIRecorder represents internal recorder config for API logs
|
|
type InternalAPIRecorder struct {
|
|
Enable LogField `json:"enable" yaml:"enable"`
|
|
Retention LogField `json:"retention" yaml:"retention"`
|
|
MaintenanceInterval LogField `json:"maintenanceInterval" yaml:"maintenanceInterval"`
|
|
OrphanGracePeriod LogField `json:"orphanGracePeriod" yaml:"orphanGracePeriod"`
|
|
}
|
|
|
|
// InternalErrorRecorder represents internal recorder config for Error logs
|
|
type InternalErrorRecorder struct {
|
|
InternalRecorder `json:",inline" yaml:",inline"`
|
|
}
|
|
|
|
// InternalAuditRecorder represents internal recorder config for Audit logs
|
|
type InternalAuditRecorder struct {
|
|
Enable LogField `json:"enable" yaml:"enable"`
|
|
}
|
|
|
|
// WebhookConfig represents base configuration for a Webhook target
|
|
type WebhookConfig struct {
|
|
Name LogField `json:"name" yaml:"name"`
|
|
Enable LogField `json:"enable" yaml:"enable"`
|
|
Endpoint LogField `json:"endpoint" yaml:"endpoint"`
|
|
AuthToken LogField `json:"authToken" yaml:"authToken"`
|
|
ClientCert LogField `json:"clientCert" yaml:"clientCert"`
|
|
ClientKey LogField `json:"clientKey" yaml:"clientKey"`
|
|
Proxy LogField `json:"proxy" yaml:"proxy"`
|
|
BatchSize LogField `json:"batchSize" yaml:"batchSize"`
|
|
MaxRetry LogField `json:"maxRetry" yaml:"maxRetry"`
|
|
RetryInterval LogField `json:"retryInterval" yaml:"retryInterval"`
|
|
BatchPayloadSize LogField `json:"batchPayloadSize" yaml:"batchPayloadSize"`
|
|
HTTPTimeout LogField `json:"httpTimeout" yaml:"httpTimeout"`
|
|
TLSSkipVerify LogField `json:"tlsSkipVerify" yaml:"tlsSkipVerify"`
|
|
Encoding LogField `json:"encoding" yaml:"encoding"`
|
|
}
|
|
|
|
// KafkaTLSConfig represents TLS configuration for Kafka
|
|
type KafkaTLSConfig struct {
|
|
Enable LogField `json:"enable" yaml:"enable"`
|
|
SkipVerify LogField `json:"skipVerify" yaml:"skipVerify"`
|
|
ClientAuth LogField `json:"clientAuth" yaml:"clientAuth"`
|
|
ClientTLSCert LogField `json:"clientTLSCert" yaml:"clientTLSCert"`
|
|
ClientTLSKey LogField `json:"clientTLSKey" yaml:"clientTLSKey"`
|
|
}
|
|
|
|
// KafkaSASLConfig represents SASL configuration for Kafka
|
|
type KafkaSASLConfig struct {
|
|
Enable LogField `json:"enable" yaml:"enable"`
|
|
Username LogField `json:"username" yaml:"username"`
|
|
Password LogField `json:"password" yaml:"password"`
|
|
Mechanism LogField `json:"mechanism" yaml:"mechanism"`
|
|
KrbRealm LogField `json:"krbRealm" yaml:"krbRealm"`
|
|
KrbKeytab LogField `json:"krbKeytab" yaml:"krbKeytab"`
|
|
KrbConfigPath LogField `json:"krbConfigPath" yaml:"krbConfigPath"`
|
|
KrbPrincipal LogField `json:"krbPrincipal" yaml:"krbPrincipal"`
|
|
}
|
|
|
|
// KafkaConfig represents base configuration for a Kafka target
|
|
type KafkaConfig struct {
|
|
Name LogField `json:"name" yaml:"name"`
|
|
Enable LogField `json:"enable" yaml:"enable"`
|
|
Brokers LogField `json:"brokers" yaml:"brokers"`
|
|
Topic LogField `json:"topic" yaml:"topic"`
|
|
Version LogField `json:"version" yaml:"version"`
|
|
TLS KafkaTLSConfig `json:"tls" yaml:"tls"`
|
|
SASL KafkaSASLConfig `json:"sasl" yaml:"sasl"`
|
|
MaxRetry LogField `json:"maxRetry" yaml:"maxRetry"`
|
|
RetryInterval LogField `json:"retryInterval" yaml:"retryInterval"`
|
|
}
|
|
|
|
// QueueConfig represents the global queue configuration for a log type
|
|
type QueueConfig struct {
|
|
Dir LogField `json:"dir" yaml:"dir"`
|
|
DirMaxSize LogField `json:"dirMaxSize" yaml:"dirMaxSize"`
|
|
FlushTimeout LogField `json:"flushTimeout" yaml:"flushTimeout"`
|
|
}
|
|
|
|
// ExternalConfig represents external target settings for a log type
|
|
type ExternalConfig struct {
|
|
Queue QueueConfig `json:"queue" yaml:"queue"`
|
|
Webhook []WebhookConfig `json:"webhook" yaml:"webhook"`
|
|
Kafka []KafkaConfig `json:"kafka" yaml:"kafka"`
|
|
}
|
|
|
|
// LogRecorderAPIConfig represents configuration for API log type
|
|
type LogRecorderAPIConfig struct {
|
|
EnvOverrides []EnvOverride `json:"envOverrides,omitempty" yaml:"-"`
|
|
Internal InternalAPIRecorder `json:"internal" yaml:"internal"`
|
|
External ExternalConfig `json:"external" yaml:"external"`
|
|
}
|
|
|
|
// LogRecorderErrorConfig represents configuration for Error log type
|
|
type LogRecorderErrorConfig struct {
|
|
EnvOverrides []EnvOverride `json:"envOverrides,omitempty" yaml:"-"`
|
|
Internal InternalErrorRecorder `json:"internal" yaml:"internal"`
|
|
External ExternalConfig `json:"external" yaml:"external"`
|
|
}
|
|
|
|
// LogRecorderAuditConfig represents configuration for Audit log type
|
|
type LogRecorderAuditConfig struct {
|
|
EnvOverrides []EnvOverride `json:"envOverrides,omitempty" yaml:"-"`
|
|
Internal InternalAuditRecorder `json:"internal" yaml:"internal"`
|
|
External ExternalConfig `json:"external" yaml:"external"`
|
|
}
|
|
|
|
// kvBuilder helps build KV strings efficiently
|
|
type kvBuilder struct {
|
|
sb strings.Builder
|
|
}
|
|
|
|
func (b *kvBuilder) add(key, value string) {
|
|
if b.sb.Len() > 0 {
|
|
b.sb.WriteString(" ")
|
|
}
|
|
if strings.Contains(value, " ") {
|
|
fmt.Fprintf(&b.sb, "%s=%q", key, value)
|
|
} else {
|
|
fmt.Fprintf(&b.sb, "%s=%s", key, value)
|
|
}
|
|
}
|
|
|
|
func (b *kvBuilder) String() string {
|
|
return b.sb.String()
|
|
}
|
|
|
|
// parseInternalRecorder parses SubsysConfig into InternalRecorder with descriptions from Help
|
|
func parseInternalRecorder(sc SubsysConfig, help Help) InternalRecorder {
|
|
return InternalRecorder{
|
|
Enable: getLogField(sc, help, logKeyEnable),
|
|
DriveLimit: getLogField(sc, help, logKeyDriveLimit),
|
|
FlushCount: getLogField(sc, help, logKeyFlushCount),
|
|
FlushInterval: getLogField(sc, help, logKeyFlushInterval),
|
|
}
|
|
}
|
|
|
|
// parseInternalAPIRecorder parses SubsysConfig into InternalAPIRecorder with descriptions from Help
|
|
func parseInternalAPIRecorder(sc SubsysConfig, help Help) InternalAPIRecorder {
|
|
return InternalAPIRecorder{
|
|
Enable: getLogField(sc, help, logKeyEnable),
|
|
Retention: getLogField(sc, help, logKeyRetention),
|
|
MaintenanceInterval: getLogField(sc, help, logKeyMaintenanceInterval),
|
|
OrphanGracePeriod: getLogField(sc, help, logKeyOrphanGracePeriod),
|
|
}
|
|
}
|
|
|
|
// parseInternalErrorRecorder parses SubsysConfig into InternalErrorRecorder with descriptions from Help
|
|
func parseInternalErrorRecorder(sc SubsysConfig, help Help) InternalErrorRecorder {
|
|
return InternalErrorRecorder{InternalRecorder: parseInternalRecorder(sc, help)}
|
|
}
|
|
|
|
// parseInternalAuditRecorder parses SubsysConfig into InternalAuditRecorder with descriptions from Help
|
|
func parseInternalAuditRecorder(sc SubsysConfig, help Help) InternalAuditRecorder {
|
|
return InternalAuditRecorder{
|
|
Enable: getLogField(sc, help, logKeyEnable),
|
|
}
|
|
}
|
|
|
|
// parseQueueConfig parses SubsysConfig into QueueConfig with descriptions from Help
|
|
func parseQueueConfig(sc SubsysConfig, help Help) QueueConfig {
|
|
return QueueConfig{
|
|
Dir: getLogField(sc, help, logKeyDir),
|
|
DirMaxSize: getLogField(sc, help, logKeyDirMaxSize),
|
|
FlushTimeout: getLogField(sc, help, logKeyFlushTimeout),
|
|
}
|
|
}
|
|
|
|
// parseWebhookConfig parses SubsysConfig into WebhookConfig with descriptions from Help
|
|
func parseWebhookConfig(sc SubsysConfig, help Help) WebhookConfig {
|
|
cfg := WebhookConfig{
|
|
Name: getLogField(sc, help, logKeyName),
|
|
Enable: getLogField(sc, help, logKeyEnable),
|
|
Endpoint: getLogField(sc, help, logKeyEndpoint),
|
|
AuthToken: getLogField(sc, help, logKeyAuthToken),
|
|
ClientCert: getLogField(sc, help, logKeyClientCert),
|
|
ClientKey: getLogField(sc, help, logKeyClientKey),
|
|
Proxy: getLogField(sc, help, logKeyProxy),
|
|
BatchSize: getLogField(sc, help, logKeyBatchSize),
|
|
MaxRetry: getLogField(sc, help, logKeyMaxRetry),
|
|
RetryInterval: getLogField(sc, help, logKeyRetryInterval),
|
|
BatchPayloadSize: getLogField(sc, help, logKeyBatchPayloadSize),
|
|
HTTPTimeout: getLogField(sc, help, logKeyHTTPTimeout),
|
|
TLSSkipVerify: getLogField(sc, help, logKeyTLSSkipVerify),
|
|
Encoding: getLogField(sc, help, logKeyEncoding),
|
|
}
|
|
// Name comes from sc.Target, not from Lookup; use Default if empty
|
|
cfg.Name.Value = sc.Target
|
|
if cfg.Name.Value == "" {
|
|
cfg.Name.Value = Default
|
|
}
|
|
return cfg
|
|
}
|
|
|
|
// parseKafkaConfig parses SubsysConfig into KafkaConfig with descriptions from Help
|
|
func parseKafkaConfig(sc SubsysConfig, help Help) KafkaConfig {
|
|
cfg := KafkaConfig{
|
|
Name: getLogField(sc, help, logKeyName),
|
|
Enable: getLogField(sc, help, logKeyEnable),
|
|
Brokers: getLogField(sc, help, logKeyBrokers),
|
|
Topic: getLogField(sc, help, logKeyTopic),
|
|
Version: getLogField(sc, help, logKeyVersion),
|
|
MaxRetry: getLogField(sc, help, logKeyMaxRetry),
|
|
RetryInterval: getLogField(sc, help, logKeyRetryInterval),
|
|
TLS: KafkaTLSConfig{
|
|
Enable: getLogField(sc, help, logKeyTLS),
|
|
SkipVerify: getLogField(sc, help, logKeyTLSSkipVerify),
|
|
ClientAuth: getLogField(sc, help, logKeyTLSClientAuth),
|
|
ClientTLSCert: getLogField(sc, help, logKeyClientTLSCert),
|
|
ClientTLSKey: getLogField(sc, help, logKeyClientTLSKey),
|
|
},
|
|
SASL: KafkaSASLConfig{
|
|
Enable: getLogField(sc, help, logKeySASL),
|
|
Username: getLogField(sc, help, logKeySASLUsername),
|
|
Password: getLogField(sc, help, logKeySASLPassword),
|
|
Mechanism: getLogField(sc, help, logKeySASLMechanism),
|
|
KrbRealm: getLogField(sc, help, logKeySASLKrbRealm),
|
|
KrbKeytab: getLogField(sc, help, logKeySASLKrbKeytab),
|
|
KrbConfigPath: getLogField(sc, help, logKeySASLKrbConfig),
|
|
KrbPrincipal: getLogField(sc, help, logKeySASLKrbPrincipal),
|
|
},
|
|
}
|
|
// Name comes from sc.Target, not from Lookup; use Default if empty
|
|
cfg.Name.Value = sc.Target
|
|
if cfg.Name.Value == "" {
|
|
cfg.Name.Value = Default
|
|
}
|
|
return cfg
|
|
}
|
|
|
|
// fetchAndParseConfig fetches config for a subsystem and parses it
|
|
func (adm *AdminClient) fetchAndParseConfig(ctx context.Context, subSys string) ([]SubsysConfig, error) {
|
|
buf, err := adm.GetConfigKV(ctx, subSys)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return ParseServerConfigOutput(string(buf))
|
|
}
|
|
|
|
// GetAPILogConfig returns the API log recorder configuration
|
|
func (adm *AdminClient) GetAPILogConfig(ctx context.Context) (LogRecorderAPIConfig, error) {
|
|
var cfg LogRecorderAPIConfig
|
|
|
|
// Fetch help for internal config
|
|
internalHelp, err := adm.HelpConfigKV(ctx, LogAPIInternalSubSys, "", false)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get help for %s: %w", LogAPIInternalSubSys, err)
|
|
}
|
|
|
|
// Fetch internal config
|
|
internalConfigs, err := adm.fetchAndParseConfig(ctx, LogAPIInternalSubSys)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get %s config: %w", LogAPIInternalSubSys, err)
|
|
}
|
|
if len(internalConfigs) > 0 {
|
|
cfg.Internal = parseInternalAPIRecorder(internalConfigs[0], internalHelp)
|
|
cfg.EnvOverrides = append(cfg.EnvOverrides, internalConfigs[0].GetEnvOverrides()...)
|
|
}
|
|
|
|
// Fetch help for queue config
|
|
queueHelp, err := adm.HelpConfigKV(ctx, LogAPIQueueSubSys, "", false)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get help for %s: %w", LogAPIQueueSubSys, err)
|
|
}
|
|
|
|
// Fetch queue config
|
|
queueConfigs, err := adm.fetchAndParseConfig(ctx, LogAPIQueueSubSys)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get %s config: %w", LogAPIQueueSubSys, err)
|
|
}
|
|
if len(queueConfigs) > 0 {
|
|
cfg.External.Queue = parseQueueConfig(queueConfigs[0], queueHelp)
|
|
cfg.EnvOverrides = append(cfg.EnvOverrides, queueConfigs[0].GetEnvOverrides()...)
|
|
}
|
|
|
|
// Fetch help for webhook config
|
|
webhookHelp, err := adm.HelpConfigKV(ctx, LogAPIWebhookSubSys, "", false)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get help for %s: %w", LogAPIWebhookSubSys, err)
|
|
}
|
|
|
|
// Fetch webhook configs
|
|
webhookConfigs, err := adm.fetchAndParseConfig(ctx, LogAPIWebhookSubSys)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get %s config: %w", LogAPIWebhookSubSys, err)
|
|
}
|
|
for _, sc := range webhookConfigs {
|
|
cfg.External.Webhook = append(cfg.External.Webhook, parseWebhookConfig(sc, webhookHelp))
|
|
cfg.EnvOverrides = append(cfg.EnvOverrides, sc.GetEnvOverrides()...)
|
|
}
|
|
|
|
// Fetch help for kafka config
|
|
kafkaHelp, err := adm.HelpConfigKV(ctx, LogAPIKafkaSubSys, "", false)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get help for %s: %w", LogAPIKafkaSubSys, err)
|
|
}
|
|
|
|
// Fetch kafka configs
|
|
kafkaConfigs, err := adm.fetchAndParseConfig(ctx, LogAPIKafkaSubSys)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get %s config: %w", LogAPIKafkaSubSys, err)
|
|
}
|
|
for _, sc := range kafkaConfigs {
|
|
cfg.External.Kafka = append(cfg.External.Kafka, parseKafkaConfig(sc, kafkaHelp))
|
|
cfg.EnvOverrides = append(cfg.EnvOverrides, sc.GetEnvOverrides()...)
|
|
}
|
|
|
|
return cfg, nil
|
|
}
|
|
|
|
// GetErrorLogConfig returns the Error log recorder configuration
|
|
func (adm *AdminClient) GetErrorLogConfig(ctx context.Context) (LogRecorderErrorConfig, error) {
|
|
var cfg LogRecorderErrorConfig
|
|
|
|
// Fetch help for internal config
|
|
internalHelp, err := adm.HelpConfigKV(ctx, LogErrorInternalSubSys, "", false)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get help for %s: %w", LogErrorInternalSubSys, err)
|
|
}
|
|
|
|
// Fetch internal config
|
|
internalConfigs, err := adm.fetchAndParseConfig(ctx, LogErrorInternalSubSys)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get %s config: %w", LogErrorInternalSubSys, err)
|
|
}
|
|
if len(internalConfigs) > 0 {
|
|
cfg.Internal = parseInternalErrorRecorder(internalConfigs[0], internalHelp)
|
|
cfg.EnvOverrides = append(cfg.EnvOverrides, internalConfigs[0].GetEnvOverrides()...)
|
|
}
|
|
|
|
// Fetch help for queue config
|
|
queueHelp, err := adm.HelpConfigKV(ctx, LogErrorQueueSubSys, "", false)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get help for %s: %w", LogErrorQueueSubSys, err)
|
|
}
|
|
|
|
// Fetch queue config
|
|
queueConfigs, err := adm.fetchAndParseConfig(ctx, LogErrorQueueSubSys)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get %s config: %w", LogErrorQueueSubSys, err)
|
|
}
|
|
if len(queueConfigs) > 0 {
|
|
cfg.External.Queue = parseQueueConfig(queueConfigs[0], queueHelp)
|
|
cfg.EnvOverrides = append(cfg.EnvOverrides, queueConfigs[0].GetEnvOverrides()...)
|
|
}
|
|
|
|
// Fetch help for webhook config
|
|
webhookHelp, err := adm.HelpConfigKV(ctx, LogErrorWebhookSubSys, "", false)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get help for %s: %w", LogErrorWebhookSubSys, err)
|
|
}
|
|
|
|
// Fetch webhook configs
|
|
webhookConfigs, err := adm.fetchAndParseConfig(ctx, LogErrorWebhookSubSys)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get %s config: %w", LogErrorWebhookSubSys, err)
|
|
}
|
|
for _, sc := range webhookConfigs {
|
|
cfg.External.Webhook = append(cfg.External.Webhook, parseWebhookConfig(sc, webhookHelp))
|
|
cfg.EnvOverrides = append(cfg.EnvOverrides, sc.GetEnvOverrides()...)
|
|
}
|
|
|
|
// Fetch help for kafka config
|
|
kafkaHelp, err := adm.HelpConfigKV(ctx, LogErrorKafkaSubSys, "", false)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get help for %s: %w", LogErrorKafkaSubSys, err)
|
|
}
|
|
|
|
// Fetch kafka configs
|
|
kafkaConfigs, err := adm.fetchAndParseConfig(ctx, LogErrorKafkaSubSys)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get %s config: %w", LogErrorKafkaSubSys, err)
|
|
}
|
|
for _, sc := range kafkaConfigs {
|
|
cfg.External.Kafka = append(cfg.External.Kafka, parseKafkaConfig(sc, kafkaHelp))
|
|
cfg.EnvOverrides = append(cfg.EnvOverrides, sc.GetEnvOverrides()...)
|
|
}
|
|
|
|
return cfg, nil
|
|
}
|
|
|
|
// GetAuditLogConfig returns the Audit log recorder configuration
|
|
func (adm *AdminClient) GetAuditLogConfig(ctx context.Context) (LogRecorderAuditConfig, error) {
|
|
var cfg LogRecorderAuditConfig
|
|
|
|
// Fetch help for internal config
|
|
internalHelp, err := adm.HelpConfigKV(ctx, LogAuditInternalSubSys, "", false)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get help for %s: %w", LogAuditInternalSubSys, err)
|
|
}
|
|
|
|
// Fetch internal config
|
|
internalConfigs, err := adm.fetchAndParseConfig(ctx, LogAuditInternalSubSys)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get %s config: %w", LogAuditInternalSubSys, err)
|
|
}
|
|
if len(internalConfigs) > 0 {
|
|
cfg.Internal = parseInternalAuditRecorder(internalConfigs[0], internalHelp)
|
|
cfg.EnvOverrides = append(cfg.EnvOverrides, internalConfigs[0].GetEnvOverrides()...)
|
|
}
|
|
|
|
// Fetch help for queue config
|
|
queueHelp, err := adm.HelpConfigKV(ctx, LogAuditQueueSubSys, "", false)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get help for %s: %w", LogAuditQueueSubSys, err)
|
|
}
|
|
|
|
// Fetch queue config
|
|
queueConfigs, err := adm.fetchAndParseConfig(ctx, LogAuditQueueSubSys)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get %s config: %w", LogAuditQueueSubSys, err)
|
|
}
|
|
if len(queueConfigs) > 0 {
|
|
cfg.External.Queue = parseQueueConfig(queueConfigs[0], queueHelp)
|
|
cfg.EnvOverrides = append(cfg.EnvOverrides, queueConfigs[0].GetEnvOverrides()...)
|
|
}
|
|
|
|
// Fetch help for webhook config
|
|
webhookHelp, err := adm.HelpConfigKV(ctx, LogAuditWebhookSubSys, "", false)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get help for %s: %w", LogAuditWebhookSubSys, err)
|
|
}
|
|
|
|
// Fetch webhook configs
|
|
webhookConfigs, err := adm.fetchAndParseConfig(ctx, LogAuditWebhookSubSys)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get %s config: %w", LogAuditWebhookSubSys, err)
|
|
}
|
|
for _, sc := range webhookConfigs {
|
|
cfg.External.Webhook = append(cfg.External.Webhook, parseWebhookConfig(sc, webhookHelp))
|
|
cfg.EnvOverrides = append(cfg.EnvOverrides, sc.GetEnvOverrides()...)
|
|
}
|
|
|
|
// Fetch help for kafka config
|
|
kafkaHelp, err := adm.HelpConfigKV(ctx, LogAuditKafkaSubSys, "", false)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get help for %s: %w", LogAuditKafkaSubSys, err)
|
|
}
|
|
|
|
// Fetch kafka configs
|
|
kafkaConfigs, err := adm.fetchAndParseConfig(ctx, LogAuditKafkaSubSys)
|
|
if err != nil {
|
|
return cfg, fmt.Errorf("failed to get %s config: %w", LogAuditKafkaSubSys, err)
|
|
}
|
|
for _, sc := range kafkaConfigs {
|
|
cfg.External.Kafka = append(cfg.External.Kafka, parseKafkaConfig(sc, kafkaHelp))
|
|
cfg.EnvOverrides = append(cfg.EnvOverrides, sc.GetEnvOverrides()...)
|
|
}
|
|
|
|
return cfg, nil
|
|
}
|
|
|
|
// buildInternalRecorderKV builds the KV string for internal recorder config
|
|
func buildInternalRecorderKV(cfg InternalRecorder, subSys string) string {
|
|
var kv kvBuilder
|
|
kv.add(logKeyEnable, cfg.Enable.Value)
|
|
kv.add(logKeyDriveLimit, cfg.DriveLimit.Value)
|
|
kv.add(logKeyFlushCount, cfg.FlushCount.Value)
|
|
kv.add(logKeyFlushInterval, cfg.FlushInterval.Value)
|
|
return subSys + " " + kv.String()
|
|
}
|
|
|
|
// buildInternalAPIKV builds the KV string for internal API recorder config
|
|
func buildInternalAPIKV(cfg InternalAPIRecorder) string {
|
|
var kv kvBuilder
|
|
kv.add(logKeyEnable, cfg.Enable.Value)
|
|
if cfg.Retention.Value != "" {
|
|
kv.add(logKeyRetention, cfg.Retention.Value)
|
|
}
|
|
if cfg.MaintenanceInterval.Value != "" {
|
|
kv.add(logKeyMaintenanceInterval, cfg.MaintenanceInterval.Value)
|
|
}
|
|
if cfg.OrphanGracePeriod.Value != "" {
|
|
kv.add(logKeyOrphanGracePeriod, cfg.OrphanGracePeriod.Value)
|
|
}
|
|
return LogAPIInternalSubSys + " " + kv.String()
|
|
}
|
|
|
|
// buildInternalErrorKV builds the KV string for internal Error recorder config
|
|
func buildInternalErrorKV(cfg InternalErrorRecorder) string {
|
|
return buildInternalRecorderKV(cfg.InternalRecorder, LogErrorInternalSubSys)
|
|
}
|
|
|
|
// buildInternalAuditKV builds the KV string for internal Audit recorder config
|
|
func buildInternalAuditKV(cfg InternalAuditRecorder) string {
|
|
var kv kvBuilder
|
|
kv.add(logKeyEnable, cfg.Enable.Value)
|
|
return LogAuditInternalSubSys + " " + kv.String()
|
|
}
|
|
|
|
// buildQueueKV builds the KV string for queue config
|
|
func buildQueueKV(cfg QueueConfig, subSys string) string {
|
|
var kv kvBuilder
|
|
kv.add(logKeyDir, cfg.Dir.Value)
|
|
kv.add(logKeyDirMaxSize, cfg.DirMaxSize.Value)
|
|
kv.add(logKeyFlushTimeout, cfg.FlushTimeout.Value)
|
|
return subSys + " " + kv.String()
|
|
}
|
|
|
|
// buildWebhookKV builds the KV string for webhook config (base fields)
|
|
func buildWebhookKV(cfg WebhookConfig, subSys string) string {
|
|
var kv kvBuilder
|
|
kv.add(logKeyEnable, cfg.Enable.Value)
|
|
kv.add(logKeyEndpoint, cfg.Endpoint.Value)
|
|
kv.add(logKeyAuthToken, cfg.AuthToken.Value)
|
|
kv.add(logKeyClientCert, cfg.ClientCert.Value)
|
|
kv.add(logKeyClientKey, cfg.ClientKey.Value)
|
|
kv.add(logKeyProxy, cfg.Proxy.Value)
|
|
kv.add(logKeyBatchSize, cfg.BatchSize.Value)
|
|
kv.add(logKeyMaxRetry, cfg.MaxRetry.Value)
|
|
kv.add(logKeyRetryInterval, cfg.RetryInterval.Value)
|
|
kv.add(logKeyBatchPayloadSize, cfg.BatchPayloadSize.Value)
|
|
kv.add(logKeyHTTPTimeout, cfg.HTTPTimeout.Value)
|
|
kv.add(logKeyTLSSkipVerify, cfg.TLSSkipVerify.Value)
|
|
kv.add(logKeyEncoding, cfg.Encoding.Value)
|
|
|
|
target := subSys
|
|
if cfg.Name.Value != "" && cfg.Name.Value != Default {
|
|
target = subSys + SubSystemSeparator + cfg.Name.Value
|
|
}
|
|
return target + " " + kv.String()
|
|
}
|
|
|
|
// buildKafkaKV builds the KV string for kafka config (base fields)
|
|
func buildKafkaKV(cfg KafkaConfig, subSys string) string {
|
|
var kv kvBuilder
|
|
kv.add(logKeyEnable, cfg.Enable.Value)
|
|
kv.add(logKeyBrokers, cfg.Brokers.Value)
|
|
kv.add(logKeyTopic, cfg.Topic.Value)
|
|
kv.add(logKeyVersion, cfg.Version.Value)
|
|
kv.add(logKeyTLS, cfg.TLS.Enable.Value)
|
|
kv.add(logKeyTLSSkipVerify, cfg.TLS.SkipVerify.Value)
|
|
kv.add(logKeyTLSClientAuth, cfg.TLS.ClientAuth.Value)
|
|
kv.add(logKeyClientTLSCert, cfg.TLS.ClientTLSCert.Value)
|
|
kv.add(logKeyClientTLSKey, cfg.TLS.ClientTLSKey.Value)
|
|
kv.add(logKeySASL, cfg.SASL.Enable.Value)
|
|
kv.add(logKeySASLUsername, cfg.SASL.Username.Value)
|
|
kv.add(logKeySASLPassword, cfg.SASL.Password.Value)
|
|
kv.add(logKeySASLMechanism, cfg.SASL.Mechanism.Value)
|
|
kv.add(logKeySASLKrbRealm, cfg.SASL.KrbRealm.Value)
|
|
kv.add(logKeySASLKrbKeytab, cfg.SASL.KrbKeytab.Value)
|
|
kv.add(logKeySASLKrbConfig, cfg.SASL.KrbConfigPath.Value)
|
|
kv.add(logKeySASLKrbPrincipal, cfg.SASL.KrbPrincipal.Value)
|
|
kv.add(logKeyMaxRetry, cfg.MaxRetry.Value)
|
|
kv.add(logKeyRetryInterval, cfg.RetryInterval.Value)
|
|
|
|
target := subSys
|
|
if cfg.Name.Value != "" && cfg.Name.Value != Default {
|
|
target = subSys + SubSystemSeparator + cfg.Name.Value
|
|
}
|
|
return target + " " + kv.String()
|
|
}
|
|
|
|
// getCurrentTargets fetches current targets from server for a subsystem
|
|
func (adm *AdminClient) getCurrentTargets(ctx context.Context, subSys string) (map[string]bool, error) {
|
|
configs, err := adm.fetchAndParseConfig(ctx, subSys)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
targets := make(map[string]bool)
|
|
for _, sc := range configs {
|
|
name := sc.Target
|
|
if name == "" {
|
|
name = Default
|
|
}
|
|
targets[name] = true
|
|
}
|
|
return targets, nil
|
|
}
|
|
|
|
// deleteRemovedTargets deletes targets that exist on server but not in the new config
|
|
func (adm *AdminClient) deleteRemovedTargets(ctx context.Context, subSys string, newNames map[string]bool) error {
|
|
currentTargets, err := adm.getCurrentTargets(ctx, subSys)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for target := range currentTargets {
|
|
if !newNames[target] && target != Default {
|
|
// Delete this target
|
|
targetKey := subSys + SubSystemSeparator + target
|
|
if _, err := adm.DelConfigKV(ctx, targetKey); err != nil {
|
|
return fmt.Errorf("failed to delete %s: %w", targetKey, err)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// SetAPILogConfig sets the API log recorder configuration
|
|
func (adm *AdminClient) SetAPILogConfig(ctx context.Context, cfg LogRecorderAPIConfig) error {
|
|
// Assign names to unnamed targets using index and check for duplicates
|
|
webhookNames := make(map[string]bool)
|
|
for i := range cfg.External.Webhook {
|
|
name := cfg.External.Webhook[i].Name.Value
|
|
if name == "" {
|
|
name = fmt.Sprintf("target-%d", i+1)
|
|
cfg.External.Webhook[i].Name.Value = name
|
|
}
|
|
if webhookNames[name] {
|
|
return fmt.Errorf("duplicate webhook target name: %s", name)
|
|
}
|
|
webhookNames[name] = true
|
|
}
|
|
|
|
kafkaNames := make(map[string]bool)
|
|
for i := range cfg.External.Kafka {
|
|
name := cfg.External.Kafka[i].Name.Value
|
|
if name == "" {
|
|
name = fmt.Sprintf("target-%d", i+1)
|
|
cfg.External.Kafka[i].Name.Value = name
|
|
}
|
|
if kafkaNames[name] {
|
|
return fmt.Errorf("duplicate kafka target name: %s", name)
|
|
}
|
|
kafkaNames[name] = true
|
|
}
|
|
|
|
// Delete removed webhook targets
|
|
if err := adm.deleteRemovedTargets(ctx, LogAPIWebhookSubSys, webhookNames); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Delete removed kafka targets
|
|
if err := adm.deleteRemovedTargets(ctx, LogAPIKafkaSubSys, kafkaNames); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Set internal config
|
|
if _, err := adm.SetConfigKV(ctx, buildInternalAPIKV(cfg.Internal)); err != nil {
|
|
return fmt.Errorf("failed to set %s config: %w", LogAPIInternalSubSys, err)
|
|
}
|
|
|
|
// Set queue config
|
|
if _, err := adm.SetConfigKV(ctx, buildQueueKV(cfg.External.Queue, LogAPIQueueSubSys)); err != nil {
|
|
return fmt.Errorf("failed to set %s config: %w", LogAPIQueueSubSys, err)
|
|
}
|
|
|
|
// Set webhook configs
|
|
for _, w := range cfg.External.Webhook {
|
|
if _, err := adm.SetConfigKV(ctx, buildWebhookKV(w, LogAPIWebhookSubSys)); err != nil {
|
|
return fmt.Errorf("failed to set webhook config for %s: %w", w.Name.Value, err)
|
|
}
|
|
}
|
|
|
|
// Set kafka configs
|
|
for _, k := range cfg.External.Kafka {
|
|
if _, err := adm.SetConfigKV(ctx, buildKafkaKV(k, LogAPIKafkaSubSys)); err != nil {
|
|
return fmt.Errorf("failed to set kafka config for %s: %w", k.Name.Value, err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// SetErrorLogConfig sets the Error log recorder configuration
|
|
func (adm *AdminClient) SetErrorLogConfig(ctx context.Context, cfg LogRecorderErrorConfig) error {
|
|
// Assign names to unnamed targets using index and check for duplicates
|
|
webhookNames := make(map[string]bool)
|
|
for i := range cfg.External.Webhook {
|
|
name := cfg.External.Webhook[i].Name.Value
|
|
if name == "" {
|
|
name = fmt.Sprintf("target-%d", i+1)
|
|
cfg.External.Webhook[i].Name.Value = name
|
|
}
|
|
if webhookNames[name] {
|
|
return fmt.Errorf("duplicate webhook target name: %s", name)
|
|
}
|
|
webhookNames[name] = true
|
|
}
|
|
|
|
kafkaNames := make(map[string]bool)
|
|
for i := range cfg.External.Kafka {
|
|
name := cfg.External.Kafka[i].Name.Value
|
|
if name == "" {
|
|
name = fmt.Sprintf("target-%d", i+1)
|
|
cfg.External.Kafka[i].Name.Value = name
|
|
}
|
|
if kafkaNames[name] {
|
|
return fmt.Errorf("duplicate kafka target name: %s", name)
|
|
}
|
|
kafkaNames[name] = true
|
|
}
|
|
|
|
// Delete removed webhook targets
|
|
if err := adm.deleteRemovedTargets(ctx, LogErrorWebhookSubSys, webhookNames); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Delete removed kafka targets
|
|
if err := adm.deleteRemovedTargets(ctx, LogErrorKafkaSubSys, kafkaNames); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Set internal config
|
|
if _, err := adm.SetConfigKV(ctx, buildInternalErrorKV(cfg.Internal)); err != nil {
|
|
return fmt.Errorf("failed to set %s config: %w", LogErrorInternalSubSys, err)
|
|
}
|
|
|
|
// Set queue config
|
|
if _, err := adm.SetConfigKV(ctx, buildQueueKV(cfg.External.Queue, LogErrorQueueSubSys)); err != nil {
|
|
return fmt.Errorf("failed to set %s config: %w", LogErrorQueueSubSys, err)
|
|
}
|
|
|
|
// Set webhook configs
|
|
for _, w := range cfg.External.Webhook {
|
|
if _, err := adm.SetConfigKV(ctx, buildWebhookKV(w, LogErrorWebhookSubSys)); err != nil {
|
|
return fmt.Errorf("failed to set webhook config for %s: %w", w.Name.Value, err)
|
|
}
|
|
}
|
|
|
|
// Set kafka configs
|
|
for _, k := range cfg.External.Kafka {
|
|
if _, err := adm.SetConfigKV(ctx, buildKafkaKV(k, LogErrorKafkaSubSys)); err != nil {
|
|
return fmt.Errorf("failed to set kafka config for %s: %w", k.Name.Value, err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// SetAuditLogConfig sets the Audit log recorder configuration
|
|
func (adm *AdminClient) SetAuditLogConfig(ctx context.Context, cfg LogRecorderAuditConfig) error {
|
|
// Assign names to unnamed targets using index and check for duplicates
|
|
webhookNames := make(map[string]bool)
|
|
for i := range cfg.External.Webhook {
|
|
name := cfg.External.Webhook[i].Name.Value
|
|
if name == "" {
|
|
name = fmt.Sprintf("target-%d", i+1)
|
|
cfg.External.Webhook[i].Name.Value = name
|
|
}
|
|
if webhookNames[name] {
|
|
return fmt.Errorf("duplicate webhook target name: %s", name)
|
|
}
|
|
webhookNames[name] = true
|
|
}
|
|
|
|
kafkaNames := make(map[string]bool)
|
|
for i := range cfg.External.Kafka {
|
|
name := cfg.External.Kafka[i].Name.Value
|
|
if name == "" {
|
|
name = fmt.Sprintf("target-%d", i+1)
|
|
cfg.External.Kafka[i].Name.Value = name
|
|
}
|
|
if kafkaNames[name] {
|
|
return fmt.Errorf("duplicate kafka target name: %s", name)
|
|
}
|
|
kafkaNames[name] = true
|
|
}
|
|
|
|
// Delete removed webhook targets
|
|
if err := adm.deleteRemovedTargets(ctx, LogAuditWebhookSubSys, webhookNames); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Delete removed kafka targets
|
|
if err := adm.deleteRemovedTargets(ctx, LogAuditKafkaSubSys, kafkaNames); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Set internal config
|
|
if _, err := adm.SetConfigKV(ctx, buildInternalAuditKV(cfg.Internal)); err != nil {
|
|
return fmt.Errorf("failed to set %s config: %w", LogAuditInternalSubSys, err)
|
|
}
|
|
|
|
// Set queue config
|
|
if _, err := adm.SetConfigKV(ctx, buildQueueKV(cfg.External.Queue, LogAuditQueueSubSys)); err != nil {
|
|
return fmt.Errorf("failed to set %s config: %w", LogAuditQueueSubSys, err)
|
|
}
|
|
|
|
// Set webhook configs
|
|
for _, w := range cfg.External.Webhook {
|
|
if _, err := adm.SetConfigKV(ctx, buildWebhookKV(w, LogAuditWebhookSubSys)); err != nil {
|
|
return fmt.Errorf("failed to set webhook config for %s: %w", w.Name.Value, err)
|
|
}
|
|
}
|
|
|
|
// Set kafka configs
|
|
for _, k := range cfg.External.Kafka {
|
|
if _, err := adm.SetConfigKV(ctx, buildKafkaKV(k, LogAuditKafkaSubSys)); err != nil {
|
|
return fmt.Errorf("failed to set kafka config for %s: %w", k.Name.Value, err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// ResetAPILogConfig resets API log config to defaults
|
|
func (adm *AdminClient) ResetAPILogConfig(ctx context.Context) error {
|
|
// Delete all webhook targets
|
|
if _, err := adm.DelConfigKV(ctx, LogAPIWebhookSubSys); err != nil {
|
|
if !errors.Is(err, ErrConfigNotFound) {
|
|
return fmt.Errorf("failed to reset %s: %w", LogAPIWebhookSubSys, err)
|
|
}
|
|
}
|
|
// Delete all kafka targets
|
|
if _, err := adm.DelConfigKV(ctx, LogAPIKafkaSubSys); err != nil {
|
|
if !errors.Is(err, ErrConfigNotFound) {
|
|
return fmt.Errorf("failed to reset %s: %w", LogAPIKafkaSubSys, err)
|
|
}
|
|
}
|
|
// Reset internal config
|
|
if _, err := adm.DelConfigKV(ctx, LogAPIInternalSubSys); err != nil {
|
|
if !errors.Is(err, ErrConfigNotFound) {
|
|
return fmt.Errorf("failed to reset %s: %w", LogAPIInternalSubSys, err)
|
|
}
|
|
}
|
|
// Reset queue config
|
|
if _, err := adm.DelConfigKV(ctx, LogAPIQueueSubSys); err != nil {
|
|
if !errors.Is(err, ErrConfigNotFound) {
|
|
return fmt.Errorf("failed to reset %s: %w", LogAPIQueueSubSys, err)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ResetErrorLogConfig resets Error log config to defaults
|
|
func (adm *AdminClient) ResetErrorLogConfig(ctx context.Context) error {
|
|
if _, err := adm.DelConfigKV(ctx, LogErrorWebhookSubSys); err != nil {
|
|
if !errors.Is(err, ErrConfigNotFound) {
|
|
return fmt.Errorf("failed to reset %s: %w", LogErrorWebhookSubSys, err)
|
|
}
|
|
}
|
|
if _, err := adm.DelConfigKV(ctx, LogErrorKafkaSubSys); err != nil {
|
|
if !errors.Is(err, ErrConfigNotFound) {
|
|
return fmt.Errorf("failed to reset %s: %w", LogErrorKafkaSubSys, err)
|
|
}
|
|
}
|
|
if _, err := adm.DelConfigKV(ctx, LogErrorInternalSubSys); err != nil {
|
|
if !errors.Is(err, ErrConfigNotFound) {
|
|
return fmt.Errorf("failed to reset %s: %w", LogErrorInternalSubSys, err)
|
|
}
|
|
}
|
|
// Reset queue config
|
|
if _, err := adm.DelConfigKV(ctx, LogErrorQueueSubSys); err != nil {
|
|
if !errors.Is(err, ErrConfigNotFound) {
|
|
return fmt.Errorf("failed to reset %s: %w", LogErrorQueueSubSys, err)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ResetAuditLogConfig resets Audit log config to defaults
|
|
func (adm *AdminClient) ResetAuditLogConfig(ctx context.Context) error {
|
|
if _, err := adm.DelConfigKV(ctx, LogAuditWebhookSubSys); err != nil {
|
|
if !errors.Is(err, ErrConfigNotFound) {
|
|
return fmt.Errorf("failed to reset %s: %w", LogAuditWebhookSubSys, err)
|
|
}
|
|
}
|
|
if _, err := adm.DelConfigKV(ctx, LogAuditKafkaSubSys); err != nil {
|
|
if !errors.Is(err, ErrConfigNotFound) {
|
|
return fmt.Errorf("failed to reset %s: %w", LogAuditKafkaSubSys, err)
|
|
}
|
|
}
|
|
if _, err := adm.DelConfigKV(ctx, LogAuditInternalSubSys); err != nil {
|
|
if !errors.Is(err, ErrConfigNotFound) {
|
|
return fmt.Errorf("failed to reset %s: %w", LogAuditInternalSubSys, err)
|
|
}
|
|
}
|
|
// Reset queue config
|
|
if _, err := adm.DelConfigKV(ctx, LogAuditQueueSubSys); err != nil {
|
|
if !errors.Is(err, ErrConfigNotFound) {
|
|
return fmt.Errorf("failed to reset %s: %w", LogAuditQueueSubSys, err)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ErrConfigNotFound is returned when a config key is not found
|
|
var ErrConfigNotFound = errors.New("config key not found")
|
|
|
|
// writeLogField writes a field with optional comment
|
|
func writeLogField(sb *strings.Builder, indent, key string, field LogField) {
|
|
if field.Description != "" {
|
|
sb.WriteString(indent)
|
|
sb.WriteString("# ")
|
|
sb.WriteString(field.Description)
|
|
sb.WriteString("\n")
|
|
}
|
|
sb.WriteString(indent)
|
|
sb.WriteString(key)
|
|
sb.WriteString(": ")
|
|
sb.WriteString(quoteYAMLValue(field.Value))
|
|
sb.WriteString("\n")
|
|
}
|
|
|
|
// writeLogFieldArrayFirst writes the first field of an array item with "- " prefix
|
|
// Comment is aligned with the field key (after "- ")
|
|
func writeLogFieldArrayFirst(sb *strings.Builder, indent, key string, field LogField) {
|
|
if field.Description != "" {
|
|
sb.WriteString(indent)
|
|
sb.WriteString(" ") // Extra indent to align with key after "- "
|
|
sb.WriteString("# ")
|
|
sb.WriteString(field.Description)
|
|
sb.WriteString("\n")
|
|
}
|
|
sb.WriteString(indent)
|
|
sb.WriteString("- ")
|
|
sb.WriteString(key)
|
|
sb.WriteString(": ")
|
|
sb.WriteString(quoteYAMLValue(field.Value))
|
|
sb.WriteString("\n")
|
|
}
|
|
|
|
// quoteYAMLValue quotes value if needed for valid YAML
|
|
func quoteYAMLValue(v string) string {
|
|
if v == "" || strings.ContainsAny(v, " \t\n:#{}[]&*!|>'\"%@`") {
|
|
return fmt.Sprintf("%q", v)
|
|
}
|
|
return v
|
|
}
|
|
|
|
// writeEnvOverrides writes environment variable overrides as YAML comments
|
|
func writeEnvOverrides(sb *strings.Builder, envs []EnvOverride) {
|
|
if len(envs) == 0 {
|
|
return
|
|
}
|
|
sb.WriteString("# Environment variables set (take priority over configuration):\n")
|
|
sb.WriteString("# ---\n")
|
|
for _, env := range envs {
|
|
sb.WriteString("# ")
|
|
sb.WriteString(env.Name)
|
|
sb.WriteString("=")
|
|
sb.WriteString(env.Value)
|
|
sb.WriteString("\n")
|
|
}
|
|
sb.WriteString("# ---\n")
|
|
}
|
|
|
|
// writeExternalYAML writes the external config section as YAML
|
|
func writeExternalYAML(sb *strings.Builder, ext ExternalConfig) {
|
|
sb.WriteString("external:\n")
|
|
sb.WriteString(" queue:\n")
|
|
writeLogField(sb, " ", "dir", ext.Queue.Dir)
|
|
writeLogField(sb, " ", "dirMaxSize", ext.Queue.DirMaxSize)
|
|
writeLogField(sb, " ", "flushTimeout", ext.Queue.FlushTimeout)
|
|
|
|
if len(ext.Webhook) > 0 {
|
|
sb.WriteString(" webhook:\n")
|
|
for _, w := range ext.Webhook {
|
|
writeLogFieldArrayFirst(sb, " ", "name", w.Name)
|
|
writeLogField(sb, " ", "enable", w.Enable)
|
|
writeLogField(sb, " ", "endpoint", w.Endpoint)
|
|
writeLogField(sb, " ", "authToken", w.AuthToken)
|
|
writeLogField(sb, " ", "clientCert", w.ClientCert)
|
|
writeLogField(sb, " ", "clientKey", w.ClientKey)
|
|
writeLogField(sb, " ", "proxy", w.Proxy)
|
|
writeLogField(sb, " ", "batchSize", w.BatchSize)
|
|
writeLogField(sb, " ", "maxRetry", w.MaxRetry)
|
|
writeLogField(sb, " ", "retryInterval", w.RetryInterval)
|
|
writeLogField(sb, " ", "batchPayloadSize", w.BatchPayloadSize)
|
|
writeLogField(sb, " ", "httpTimeout", w.HTTPTimeout)
|
|
writeLogField(sb, " ", "tlsSkipVerify", w.TLSSkipVerify)
|
|
writeLogField(sb, " ", "encoding", w.Encoding)
|
|
}
|
|
}
|
|
|
|
if len(ext.Kafka) > 0 {
|
|
sb.WriteString(" kafka:\n")
|
|
for _, k := range ext.Kafka {
|
|
writeLogFieldArrayFirst(sb, " ", "name", k.Name)
|
|
writeLogField(sb, " ", "enable", k.Enable)
|
|
writeLogField(sb, " ", "brokers", k.Brokers)
|
|
writeLogField(sb, " ", "topic", k.Topic)
|
|
writeLogField(sb, " ", "version", k.Version)
|
|
sb.WriteString(" tls:\n")
|
|
writeLogField(sb, " ", "enable", k.TLS.Enable)
|
|
writeLogField(sb, " ", "skipVerify", k.TLS.SkipVerify)
|
|
writeLogField(sb, " ", "clientAuth", k.TLS.ClientAuth)
|
|
writeLogField(sb, " ", "clientTLSCert", k.TLS.ClientTLSCert)
|
|
writeLogField(sb, " ", "clientTLSKey", k.TLS.ClientTLSKey)
|
|
sb.WriteString(" sasl:\n")
|
|
writeLogField(sb, " ", "enable", k.SASL.Enable)
|
|
writeLogField(sb, " ", "username", k.SASL.Username)
|
|
writeLogField(sb, " ", "password", k.SASL.Password)
|
|
writeLogField(sb, " ", "mechanism", k.SASL.Mechanism)
|
|
writeLogField(sb, " ", "krbRealm", k.SASL.KrbRealm)
|
|
writeLogField(sb, " ", "krbKeytab", k.SASL.KrbKeytab)
|
|
writeLogField(sb, " ", "krbConfigPath", k.SASL.KrbConfigPath)
|
|
writeLogField(sb, " ", "krbPrincipal", k.SASL.KrbPrincipal)
|
|
writeLogField(sb, " ", "maxRetry", k.MaxRetry)
|
|
writeLogField(sb, " ", "retryInterval", k.RetryInterval)
|
|
}
|
|
}
|
|
}
|
|
|
|
// YAML returns the configuration as YAML with field descriptions as comments
|
|
func (c LogRecorderAPIConfig) YAML() string {
|
|
var sb strings.Builder
|
|
|
|
writeEnvOverrides(&sb, c.EnvOverrides)
|
|
|
|
sb.WriteString("internal:\n")
|
|
writeLogField(&sb, " ", "enable", c.Internal.Enable)
|
|
writeLogField(&sb, " ", "retention", c.Internal.Retention)
|
|
writeLogField(&sb, " ", "maintenanceInterval", c.Internal.MaintenanceInterval)
|
|
writeLogField(&sb, " ", "orphanGracePeriod", c.Internal.OrphanGracePeriod)
|
|
|
|
writeExternalYAML(&sb, c.External)
|
|
|
|
return sb.String()
|
|
}
|
|
|
|
// YAML returns the configuration as YAML with field descriptions as comments
|
|
func (c LogRecorderErrorConfig) YAML() string {
|
|
var sb strings.Builder
|
|
|
|
writeEnvOverrides(&sb, c.EnvOverrides)
|
|
|
|
sb.WriteString("internal:\n")
|
|
writeLogField(&sb, " ", "enable", c.Internal.Enable)
|
|
writeLogField(&sb, " ", "driveLimit", c.Internal.DriveLimit)
|
|
writeLogField(&sb, " ", "flushCount", c.Internal.FlushCount)
|
|
writeLogField(&sb, " ", "flushInterval", c.Internal.FlushInterval)
|
|
|
|
writeExternalYAML(&sb, c.External)
|
|
|
|
return sb.String()
|
|
}
|
|
|
|
// YAML returns the configuration as YAML with field descriptions as comments
|
|
func (c LogRecorderAuditConfig) YAML() string {
|
|
var sb strings.Builder
|
|
|
|
writeEnvOverrides(&sb, c.EnvOverrides)
|
|
|
|
sb.WriteString("internal:\n")
|
|
writeLogField(&sb, " ", "enable", c.Internal.Enable)
|
|
|
|
writeExternalYAML(&sb, c.External)
|
|
|
|
return sb.String()
|
|
}
|