config.yaml

apiVersion: v1
kind: ConfigMap
metadata:
    name: {{ include "pgdog.fullname" . }}
data:
    # This is pgdog.toml. You can configure anything here, incl. databases.
    # Note: don't change the port value, since it's pulled from Values.
    pgdog.toml: |
        [general]
        port                      =   {{ include "pgdog.intval" .Values.port }}
        workers                   =   {{ include "pgdog.intval" (.Values.workers | default 2) }}
        default_pool_size         =   {{ include "pgdog.intval" (.Values.defaultPoolSize | default 10) }}
        log_format                =   {{ .Values.logFormat | default "text" | quote }}
        log_level                 =   {{ .Values.logLevel | default "info" | quote }}
        {{- if hasKey .Values "minPoolSize" }}
        min_pool_size             =   {{ include "pgdog.intval" .Values.minPoolSize }}
        {{- end }}
        pooler_mode               =   {{ .Values.poolerMode | default "transaction" | quote }}
        {{- if .Values.healthcheckPort }}
        healthcheck_port          =   {{ include "pgdog.intval" .Values.healthcheckPort }}
        {{- end }}
        healthcheck_interval      =   {{ include "pgdog.intval" (.Values.healthcheckInterval | default "30_000") }}
        idle_healthcheck_interval =   {{ include "pgdog.intval" (.Values.idleHealthcheckInterval | default "30_000") }}
        idle_healthcheck_delay    =   {{ include "pgdog.intval" (.Values.idleHealthcheckDelay | default "5_000") }}
        healthcheck_timeout       =   {{ include "pgdog.intval" (.Values.healthcheckTimeout | default "5_000") }}
        {{- if hasKey .Values "banTimeout" }}
        ban_timeout               =   {{ include "pgdog.intval" .Values.banTimeout }}
        {{- end }}
        {{- if hasKey .Values "banReplicaLag" }}
        ban_replica_lag           =   {{ include "pgdog.intval" .Values.banReplicaLag }}
        {{- end }}
        {{- if hasKey .Values "banReplicaLagBytes" }}
        ban_replica_lag_bytes     =   {{ include "pgdog.intval" .Values.banReplicaLagBytes }}
        {{- end }}
        rollback_timeout          =   {{ include "pgdog.intval" (.Values.rollbackTimeout | default "5_000") }}
        load_balancing_strategy   =   {{ .Values.loadBalancingStrategy | default "round_robin" | quote }}
        read_write_strategy       =   {{ .Values.readWriteStrategy | default "conservative" | quote }}
        {{- if .Values.readWriteSplit }}
        read_write_split          =   {{ .Values.readWriteSplit | quote }}
        {{- end }}
        {{- if .Values.tlsGenerateSelfSignedCert }}
        tls_certificate           =   "/etc/pgdog-tls/tls.crt"
        tls_private_key           =   "/etc/pgdog-tls/tls.key"
        {{- else }}
        {{- if .Values.tlsCertificate }}
        tls_certificate           =   {{ .Values.tlsCertificate | quote }}
        {{- end }}
        {{- if .Values.tlsPrivateKey }}
        tls_private_key           =   {{ .Values.tlsPrivateKey | quote }}
        {{- end }}
        {{- end }}
        tls_client_required       =   {{ hasKey .Values "tlsClientRequired" | ternary .Values.tlsClientRequired "false" }}
        tls_verify                =   {{ .Values.tlsVerify | default "prefer" | quote }}
        {{- if and .Values.rdsCertificateBundle .Values.rdsCertificateBundle.enabled }}
        tls_server_ca_certificate =   "/etc/pgdog-rds-ca/rds-ca-bundle.pem"
        {{- else if .Values.tlsServerCaCertificate }}
        tls_server_ca_certificate =   {{ .Values.tlsServerCaCertificate | quote }}
        {{- end}}
        shutdown_timeout          =   {{ include "pgdog.intval" (.Values.shutdownTimeout | default "60_000") }}
        {{- if .Values.shutdownTerminationTimeout }}
        shutdown_termination_timeout =   {{ include "pgdog.intval" .Values.shutdownTerminationTimeout }}
        {{- end }}
        prepared_statements       =   {{ .Values.preparedStatements | default "extended" | quote }}
        {{- with .Values.queryParser }}
        query_parser              =   {{ . | quote }}
        {{- else }}
        {{- with .Values.queryParserEnabled }}
        query_parser_enabled      =   {{ . }}
        {{- end }}
        {{- end }}
        {{- if .Values.queryParserEngine }}
        query_parser_engine       =   {{ .Values.queryParserEngine | quote }}
        {{- end }}
        {{- if .Values.logMinDurationParse }}
        log_min_duration_parse    =   {{ include "pgdog.intval" .Values.logMinDurationParse }}
        {{- end }}
        {{- if .Values.logQuerySampleLength }}
        log_query_sample_length   =   {{ include "pgdog.intval" .Values.logQuerySampleLength }}
        {{- end }}
        {{- if .Values.regexParserLimit }}
        regex_parser_limit        =   {{ include "pgdog.intval" .Values.regexParserLimit }}
        {{- end }}
        {{- if .Values.preparedStatementsLimit }}
        prepared_statements_limit =   {{ include "pgdog.intval" .Values.preparedStatementsLimit }}
        {{- end}}
        {{- if .Values.queryCacheLimit }}
        query_cache_limit         =   {{ include "pgdog.intval" .Values.queryCacheLimit }}
        {{- end }}
        passthrough_auth          =   {{ .Values.passthroughAuth | default "disabled" | quote }}
        connect_timeout           =   {{ include "pgdog.intval" (.Values.connectTimeout | default "5_000") }}
        connect_attempts          =   {{ include "pgdog.intval" (.Values.connectAttempts | default 1) }}
        connect_attempt_delay     =   {{ include "pgdog.intval" (.Values.connectAttemptDelay | default 0) }}
        {{- if .Values.queryTimeout }}
        query_timeout             =   {{ include "pgdog.intval" .Values.queryTimeout }}
        {{- end }}
        {{- if .Values.clientIdleInTransactionTimeout }}
        client_idle_in_transaction_timeout =   {{ include "pgdog.intval" .Values.clientIdleInTransactionTimeout }}
        {{- end }}
        checkout_timeout          =   {{ include "pgdog.intval" (.Values.checkoutTimeout | default "5_000") }}
        dry_run                   =   {{ hasKey .Values "dryRun" | ternary .Values.dryRun "false" }}
        {{- if hasKey .Values "twoPhaseCommit" }}
        two_phase_commit          =   {{ .Values.twoPhaseCommit }}
        {{- end }}
        {{- if hasKey .Values "twoPhaseCommitAuto" }}
        two_phase_commit_auto     =   {{ .Values.twoPhaseCommitAuto }}
        {{- end }}
        {{- if .Values.twoPhaseCommitWalDir }}
        two_phase_commit_wal_dir  =   {{ .Values.twoPhaseCommitWalDir | quote }}
        {{- end }}
        {{- if .Values.twoPhaseCommitWalSegmentSize }}
        two_phase_commit_wal_segment_size      =   {{ include "pgdog.intval" .Values.twoPhaseCommitWalSegmentSize }}
        {{- end }}
        {{- if .Values.twoPhaseCommitWalFsyncInterval }}
        two_phase_commit_wal_fsync_interval    =   {{ include "pgdog.intval" .Values.twoPhaseCommitWalFsyncInterval }}
        {{- end }}
        {{- if .Values.twoPhaseCommitWalCheckpointInterval }}
        two_phase_commit_wal_checkpoint_interval =   {{ include "pgdog.intval" .Values.twoPhaseCommitWalCheckpointInterval }}
        {{- end }}
        {{- if .Values.systemCatalogs }}
        system_catalogs           =   {{ .Values.systemCatalogs | quote }}
        {{- end }}
        {{- if hasKey .Values "omnishardedSticky" }}
        omnisharded_sticky        =   {{ .Values.omnishardedSticky }}
        {{- end }}
        {{- if .Values.reshardingCopyFormat }}
        resharding_copy_format    =   {{ .Values.reshardingCopyFormat | quote }}
        {{- end }}
        {{- if .Values.reshardingParallelCopies }}
        resharding_parallel_copies =   {{ include "pgdog.intval" .Values.reshardingParallelCopies }}
        {{- end }}
        {{- if .Values.reshardingCopyRetryMaxAttempts }}
        resharding_copy_retry_max_attempts =   {{ include "pgdog.intval" .Values.reshardingCopyRetryMaxAttempts }}
        {{- end }}
        {{- if .Values.reshardingCopyRetryMinDelay }}
        resharding_copy_retry_min_delay =   {{ include "pgdog.intval" .Values.reshardingCopyRetryMinDelay }}
        {{- end }}
        {{- if hasKey .Values "reloadSchemaOnDdl" }}
        reload_schema_on_ddl      =   {{ .Values.reloadSchemaOnDdl }}
        {{- end }}
        {{- if .Values.loadSchema }}
        load_schema               =   {{ .Values.loadSchema | quote }}
        {{- end }}
        {{- if .Values.idleTimeout }}
        idle_timeout              =   {{ include "pgdog.intval" .Values.idleTimeout }}
        {{- end }}
        {{- if .Values.clientIdleTimeout }}
        client_idle_timeout       =   {{ include "pgdog.intval" .Values.clientIdleTimeout }}
        {{- end }}
        {{- if .Values.clientLoginTimeout }}
        client_login_timeout      =   {{ include "pgdog.intval" .Values.clientLoginTimeout }}
        {{- end }}
        mirror_queue              =   {{ include "pgdog.intval" (.Values.mirrorQueue | default 128) }}
        mirror_exposure           =   {{ .Values.mirrorExposure | default "1.0" }}
        auth_type                 =   {{ .Values.authType | default "scram" | quote }}
        cross_shard_disabled      =   {{ hasKey .Values "crossShardDisabled" | ternary .Values.crossShardDisabled "false" }}
        {{- if .Values.dnsTtl }}
        dns_ttl                   =   {{ include "pgdog.intval" .Values.dnsTtl }}
        {{- end }}
        {{- if .Values.pubSubChannelSize }}
        pub_sub_channel_size      =   {{ include "pgdog.intval" .Values.pubSubChannelSize }}
        {{- end }}
        openmetrics_port = {{ include "pgdog.intval" (.Values.openMetricsPort | default 9090) }}
        openmetrics_namespace = {{ .Values.openMetricsNamespace | default "pgdog_" | quote }}
        server_lifetime = {{ include "pgdog.intval" (.Values.serverLifetime | default 86400000) }}
        log_connections = {{ hasKey .Values "logConnections" | ternary .Values.logConnections "true" }}
        log_disconnections = {{ hasKey .Values "logDisconnections" | ternary .Values.logDisconnections "true" }}
        {{- if .Values.logDedupThreshold }}
        log_dedup_threshold = {{ include "pgdog.intval" .Values.logDedupThreshold }}
        {{- end }}
        {{- if .Values.logDedupWindow }}
        log_dedup_window = {{ include "pgdog.intval" .Values.logDedupWindow }}
        {{- end }}
        {{- if .Values.statsPeriod }}
        stats_period              =   {{ include "pgdog.intval" .Values.statsPeriod }}
        {{- end }}
        {{- if .Values.connectionRecovery }}
        connection_recovery      =   {{ .Values.connectionRecovery | quote }}
        {{- end }}
        {{- if .Values.clientConnectionRecovery }}
        client_connection_recovery =   {{ .Values.clientConnectionRecovery | quote }}
        {{- end }}
        expanded_explain = {{ hasKey .Values "expandedExplain" | ternary .Values.expandedExplain "false" }}
        {{- if hasKey .Values "lsnCheckDelay" }}
        lsn_check_delay           =   {{ include "pgdog.intval" .Values.lsnCheckDelay }}
        {{- end }}
        {{- if hasKey .Values "lsnCheckInterval" }}
        lsn_check_interval        =   {{ include "pgdog.intval" .Values.lsnCheckInterval }}
        {{- end }}
        {{- if hasKey .Values "lsnCheckTimeout" }}
        lsn_check_timeout         =   {{ include "pgdog.intval" .Values.lsnCheckTimeout }}
        {{- end }}
        {{- if .Values.rewriteShardKeyUpdates }}
        rewrite_shard_key_updates =   {{ .Values.rewriteShardKeyUpdates | quote }}
        {{- end }}
        {{- if hasKey .Values "uniqueIdMin" }}
        unique_id_min             =   {{ include "pgdog.intval" .Values.uniqueIdMin }}
        {{- end }}
        {{- if .Values.uniqueIdFunction }}
        unique_id_function        =   {{ .Values.uniqueIdFunction | quote }}
        {{- end }}
        {{- if hasKey .Values "cutoverTrafficStopThreshold" }}
        cutover_traffic_stop_threshold     =   {{ include "pgdog.intval" .Values.cutoverTrafficStopThreshold }}
        {{- end }}
        {{- if hasKey .Values "cutoverReplicationLagThreshold" }}
        cutover_replication_lag_threshold  =   {{ include "pgdog.intval" .Values.cutoverReplicationLagThreshold }}
        {{- end }}
        {{- if hasKey .Values "cutoverLastTransactionDelay" }}
        cutover_last_transaction_delay     =   {{ include "pgdog.intval" .Values.cutoverLastTransactionDelay }}
        {{- end }}
        {{- if hasKey .Values "cutoverTimeout" }}
        cutover_timeout           =   {{ include "pgdog.intval" .Values.cutoverTimeout }}
        {{- end }}
        {{- if .Values.cutoverTimeoutAction }}
        cutover_timeout_action    =   {{ .Values.cutoverTimeoutAction | quote }}
        {{- end }}
        {{- if hasKey .Values "cutoverSaveConfig" }}
        cutover_save_config       =   {{ .Values.cutoverSaveConfig }}
        {{- end }}

        {{- range .Values.databases }}
        [[databases]]
        name = {{ .name | quote }}
        host = {{ .host | quote }}
        port = {{ include "pgdog.intval" (.port | default 5432) }}
        shard = {{ include "pgdog.intval" (.shard | default 0) }}
        {{- if .databaseName }}
        database_name = {{ .databaseName | quote }}
        {{- end }}
        {{- if .user }}
        user = {{ .user | quote }}
        {{- end }}
        {{- if .password }}
        password = {{ .password | quote }}
        {{- end }}
        {{- if .poolSize }}
        pool_size = {{ include "pgdog.intval" .poolSize }}
        {{- end }}
        {{- if .minPoolSize }}
        min_pool_size = {{ include "pgdog.intval" .minPoolSize }}
        {{- end }}
        {{- if .poolerMode }}
        pooler_mode = {{ .poolerMode | quote }}
        {{- end }}
        {{- if .statementTimeout }}
        statement_timeout = {{ include "pgdog.intval" .statementTimeout }}
        {{- end }}
        {{- if .idleTimeout }}
        idle_timeout = {{ include "pgdog.intval" .idleTimeout }}
        {{- end }}
        {{- if .readOnly }}
        read_only = {{ .readOnly }}
        {{- end }}
        {{- if .role }}
        role = {{ .role | quote }}
        {{- end }}
        {{- if .serverLifetime }}
        server_lifetime = {{ include "pgdog.intval" .serverLifetime }}
        {{- end }}
        {{- if .reshardingOnly }}
        resharding_only = {{ .reshardingOnly }}
        {{- end }}
        {{- if .lbWeight }}
        lb_weight = {{ include "pgdog.intval" .lbWeight }}
        {{- end }}
        {{- end }}

        {{- range .Values.mirrors }}
        [[mirroring]]
        source_db = {{ .sourceDb | quote }}
        destination_db = {{ .destinationDb | quote }}
        {{- if or .queueLength .queueDepth }}
        queue_length = {{ include "pgdog.intval" (.queueLength | default .queueDepth) }}
        {{- end}}
        {{- if .exposure }}
        exposure = {{ .exposure }}
        {{- end }}
        {{- if .level }}
        level = {{ .level | quote }}
        {{- end }}
        {{- end }}

        {{- range .Values.shardedSchemas }}
        [[sharded_schemas]]
        database = {{ .database | quote }}
        {{- if .name }}
        name = {{ .name | quote }}
        {{- end }}
        shard = {{ include "pgdog.intval" .shard }}
        {{- end }}

        {{- range .Values.shardedTables }}
        [[sharded_tables]]
        database = {{ .database | quote }}
        {{- if .name }}
        name = {{ .name | quote }}
        {{- end }}
        column = {{ .column | quote }}
        data_type = {{ .dataType | quote }}
        {{- end }}

        {{- range .Values.shardedMappings }}
        [[sharded_mappings]]
        database = {{ .database | quote }}
        column = {{ .column | quote }}
        kind = {{ .kind | quote }}
        shard = {{ include "pgdog.intval" .shard }}
        {{- if .values }}
        values = {{ .values| toToml }}
        {{- end }}
        {{- if .start }}
        start = {{ include "pgdog.intval" .start }}
        {{- end }}
        {{- if .end }}
        end = {{ include "pgdog.intval" .end }}
        {{- end}}
        {{- end }}

        {{- range .Values.omnishardedTables }}
        [[omnisharded_tables]]
        database = {{ .database | quote }}
        {{- if .sticky }}
        sticky = {{ .sticky }}
        {{- end }}
        tables = {{ .tables | toToml }}
        {{- end }}

        {{- range .Values.plugins }}
        [[plugins]]
        name = {{ .name | quote }}
        {{- if .config }}
        config = "/etc/pgdog/{{ .name }}.toml"
        {{- end }}
        {{- end }}

        {{- if or (hasKey .Values "tcpKeepalive") (hasKey .Values "tcpTime") (hasKey .Values "tcpInterval") (hasKey .Values "tcpRetries") (hasKey .Values "tcpUserTimeout") (hasKey .Values "tcpCongestionControl") }}
        [tcp]
        {{- if hasKey .Values "tcpKeepalive" }}
        keepalive = {{ .Values.tcpKeepalive }}
        {{- end }}
        {{- if hasKey .Values "tcpTime" }}
        time = {{ include "pgdog.intval" .Values.tcpTime }}
        {{- end }}
        {{- if hasKey .Values "tcpInterval" }}
        interval = {{ include "pgdog.intval" .Values.tcpInterval }}
        {{- end }}
        {{- if hasKey .Values "tcpRetries" }}
        retries = {{ include "pgdog.intval" .Values.tcpRetries }}
        {{- end }}
        {{- if hasKey .Values "tcpUserTimeout" }}
        user_timeout = {{ include "pgdog.intval" .Values.tcpUserTimeout }}
        {{- end }}
        {{- if hasKey .Values "tcpCongestionControl" }}
        congestion_control = {{ .Values.tcpCongestionControl | quote }}
        {{- end }}
        {{- end }}

        {{- if or (hasKey .Values "memoryNetBuffer") (hasKey .Values "memoryMessageBuffer") (hasKey .Values "memoryStackSize") }}
        [memory]
        {{- if hasKey .Values "memoryNetBuffer" }}
        net_buffer = {{ .Values.memoryNetBuffer | int }}
        {{- end }}
        {{- if hasKey .Values "memoryMessageBuffer" }}
        message_buffer = {{ .Values.memoryMessageBuffer | int }}
        {{- end }}
        {{- if hasKey .Values "memoryStackSize" }}
        stack_size = {{ .Values.memoryStackSize | int }}
        {{- end }}
        {{- end }}

        {{- if .Values.adminPassword }}
        [admin]
        password = {{ .Values.adminPassword | quote }}
        {{- end }}

        {{- if and .Values.gateway.enabled .Values.gateway.connectFromPgdog }}
        [gateway]
        address = "{{ include "pgdog.fullname" . }}-gateway.{{ .Release.Namespace }}.svc.cluster.local:{{ .Values.gateway.port | default 8443 }}"
        {{- end }}

        {{- if .Values.qos }}
        [qos]
        enabled = {{ hasKey .Values.qos "enabled" | ternary .Values.qos.enabled "false" }}
        max_entries = {{ include "pgdog.intval" (.Values.qos.maxEntries | default "10_000") }}
        {{- end }}

        {{- with .Values.queryStats }}
        {{- if .enabled }}
        [query_stats]
        enabled = {{ .enabled }}
        {{- if .maxEntries }}
        max_entries = {{ include "pgdog.intval" .maxEntries }}
        {{- end }}
        {{- if .queryPlanThreshold }}
        query_plan_threshold = {{ include "pgdog.intval" .queryPlanThreshold }}
        {{- end }}
        {{- if .queryPlansCache }}
        query_plans_cache = {{ include "pgdog.intval" .queryPlansCache }}
        {{- end }}
        {{- if .queryPlanMaxAge }}
        query_plan_max_age = {{ include "pgdog.intval" .queryPlanMaxAge }}
        {{- end }}
        {{- if .maxErrors }}
        max_errors = {{ include "pgdog.intval" .maxErrors }}
        {{- end }}
        {{- if .maxErrorAge }}
        max_error_age = {{ include "pgdog.intval" .maxErrorAge }}
        {{- end }}
        {{- if .idleInTransactionThreshold }}
        idle_in_transaction_threshold = {{ include "pgdog.intval" .idleInTransactionThreshold }}
        {{- end }}
        {{- end }}
        {{- end }}

        {{- with .Values.control }}
        {{- if .enabled }}
        [control]
        {{- if .endpoint }}
        endpoint = {{ .endpoint | quote }}
        {{- end }}
        {{- if .token }}
        token = {{ .token | quote }}
        {{- end }}
        {{- if .metricsInterval }}
        metrics_interval = {{ include "pgdog.intval" .metricsInterval }}
        {{- end }}
        {{- if .statsInterval }}
        stats_interval = {{ include "pgdog.intval" .statsInterval }}
        {{- end }}
        {{- if .activeQueriesInterval }}
        active_queries_interval = {{ include "pgdog.intval" .activeQueriesInterval }}
        {{- end }}
        {{- if .errorsInterval }}
        errors_interval = {{ include "pgdog.intval" .errorsInterval }}
        {{- end }}
        {{- if .requestTimeout }}
        request_timeout = {{ include "pgdog.intval" .requestTimeout }}
        {{- end }}
        {{- if .queryTimingsChunkSize }}
        query_timings_chunk_size = {{ include "pgdog.intval" .queryTimingsChunkSize }}
        {{- end }}
        {{- if .queryTimingsNewQueryQueueSize }}
        query_timings_new_query_queue_size = {{ include "pgdog.intval" .queryTimingsNewQueryQueueSize }}
        {{- end }}
        {{- end }}
        {{- end }}

        {{- if .Values.rewrite }}
        [rewrite]
        enabled = {{ hasKey .Values.rewrite "enabled" | ternary .Values.rewrite.enabled "false" }}
        shard_key = {{ .Values.rewrite.shardKey | default "error" | quote }}
        split_inserts = {{ .Values.rewrite.splitInserts | default "error" | quote }}
        primary_key = {{ .Values.rewrite.primaryKey | default "ignore" | quote }}
        {{- end }}

        {{- if .Values.multiTenant }}
        [multi_tenant]
        column = {{ .Values.multiTenant.column | quote }}
        {{- end }}

        {{- if .Values.otel }}
        [otel]
        {{- if .Values.otel.endpoint }}
        endpoint = {{ .Values.otel.endpoint | quote }}
        {{- end }}
        {{- if .Values.otel.namespace }}
        namespace = {{ .Values.otel.namespace | quote }}
        {{- end }}
        {{- if .Values.otel.datadogApiKey }}
        datadog_api_key = {{ .Values.otel.datadogApiKey | quote }}
        {{- end }}
        {{- if .Values.otel.pushInterval }}
        push_interval = {{ include "pgdog.intval" .Values.otel.pushInterval }}
        {{- end }}
        {{- if .Values.otel.headers }}
        [otel.headers]
        {{- range $k, $v := .Values.otel.headers }}
        {{ $k }} = {{ $v | quote }}
        {{- end }}
        {{- end }}
        {{- end }}
    {{- range .Values.plugins }}
    {{- if .config }}
    {{ .name }}.toml: |
{{ .config | indent 8 }}
    {{- end }}
    {{- end }}