sys.config

[
    %    {kernel, [
    %        {logger_level, info},
    %        {logger, [
    %            {handler, console_logger, logger_std_h, #{
    %                level => debug,
    %                config => #{
    %                    type => {file, "/var/log/hellgate/console.json"},
    %                    sync_mode_qlen => 20
    %                },
    %                formatter => {logger_logstash_formatter, #{}}
    %            }}
    %        ]}
    %    ]},

    {scoper, [
        {storage, scoper_storage_logger}
    ]},

    {opentelemetry, [
        {processors, [{otel_batch_processor, #{scheduled_delay_ms => 1000}}]}
    ]},

    {hg_proto, [
        {services, #{
            limiter => "http://limiter:8022/v1/limiter",
            automaton => "http://machinegun:8022/v1/automaton",
            eventsink => "http://machinegun:8022/v1/event_sink",
            accounter => "http://shumway:8022/accounter",
            party_management => "http://party-management:8022/v1/processing/partymgmt",
            customer_management => "http://hellgate:8022/v1/processing/customer_management",
            % TODO make more consistent
            recurrent_paytool => "http://hellgate:8022/v1/processing/recpaytool",
            fault_detector => "http://fault-detector:8022/v1/fault-detector"
        }}
    ]},

    {hellgate, [
        {ip, "::"},
        {port, 8022},
        {default_woody_handling_timeout, 30000},
        %% 1 sec above cowboy's request_timeout
        {shutdown_timeout, 7000},
        {protocol_opts, #{
            % Bump keepalive timeout up to a minute
            request_timeout => 6000,
            % Should be greater than any other timeouts
            idle_timeout => infinity
        }},
        %% OTEL log handler configuration
        {otel_log_level, info},
        {otel_log_max_queue_size, 2048},
        {otel_log_scheduled_delay_ms, 1000},
        {otel_log_exporting_timeout_ms, 300000},
        {scoper_event_handler_options, #{
            event_handler_opts => #{
                formatter_opts => #{
                    max_length => 1000
                },
                events_severity => #{
                    %% Maybe disregard those events by lowering their severity level
                    ['call service'] => info,
                    ['service result'] => info,
                    ['invoke service handler'] => info,
                    ['service handler result'] => info,
                    ['service handler result', error, business] => warning,
                    ['client cache hit'] => info
                }
            }
        }},
        {proxy_opts, #{
            transport_opts => #{}
        }},
        {health_check_liveness, #{
            disk => {erl_health, disk, ["/", 99]},
            memory => {erl_health, cg_memory, [70]},
            service => {erl_health, service, [<<"hellgate">>]}
        }},
        {health_check_readiness, #{
            dmt_client => {dmt_client, health_check, []},
            progressor =>
                {progressor, health_check, [
                    %% list of progressors namespaces for tests
                    [invoice_template]
                ]}
        }},
        {payment_retry_policy, #{
            processed => {exponential, {max_total_timeout, 30}, 2, 1},
            captured => no_retry,
            refunded => no_retry
        }},
        {inspect_timeout, 3000},
        {payment, #{
            % Payment error codes that signals hellgate to attempt another route
            % (default = [<<"preauthorization_failed">>])
            default_transient_errors => [<<"preauthorization_failed">>]
        }},
        {fault_detector, #{
            enabled => true,
            % Woody RPC request timeout (ms).
            timeout => 4000,
            % How to measure technical availability of providers?
            availability => #{
                % We consider provider as _unavailable_ if their failrate is greater than this
                % threshold (0.0 is no failures at all / 1.0 is every attempt to interact fails).
                critical_fail_rate => 0.7,
                % For how long to account operations in failrate computation (ms)?
                sliding_window => 60000,
                % If operation takes too long, when do we consider it as failure (ms)?
                operation_time_limit => 10000,
                % With which time resolution we should compute failrate (s)?
                % Less means quicker reaction to failures at the cost of increased load on service.
                pre_aggregation_size => 2
            },
            % How to measure providers' conversion (aka business availability)?
            conversion => #{
                % Which business level error codes aren't treated as failures?
                benign_failures => [
                    insufficient_funds,
                    rejected_by_issuer,
                    processing_deadline_reached
                ],
                % We consider provider as _unavailable_ if their failrate is greater than this
                % threshold (0.0 is no failures at all / 1.0 is every attempt to interact fails).
                critical_fail_rate => 0.7,
                % For how long to account operations in failrate computation (ms)?
                sliding_window => 60000,
                % If operation takes too long, when do we consider it as failure (ms)?
                operation_time_limit => 1200000,
                % With which time resolution we should compute failrate (s)?
                % Less means quicker reaction to failures at the cost of increased load on service.
                pre_aggregation_size => 2
            }
        }},
        {binding, #{
            max_sync_interval => <<"5s">>,
            outdated_sync_interval => <<"1440m">>,
            outdate_timeout => <<"180m">>
        }},
        %% progressor | machinegun
        {backend, progressor}
    ]},

    {dmt_client, [
        % milliseconds
        {cache_update_interval, 5000},
        {max_cache_size, #{
            elements => 20,
            % 50Mb
            memory => 52428800
        }},
        {woody_event_handlers, [
            {scoper_woody_event_handler, #{
                event_handler_opts => #{
                    formatter_opts => #{
                        max_length => 1000
                    },
                    events_severity => #{
                        %% Was 'info'
                        ['service handler result', error, business] => warning
                    }
                }
            }}
        ]},
        {service_urls, #{
            'AuthorManagement' => <<"http://dmt:8022/v1/domain/author">>,
            'Repository' => <<"http://dmt:8022/v1/domain/repository">>,
            'RepositoryClient' => <<"http://dmt:8022/v1/domain/repository_client">>
        }}
    ]},

    {party_client, [
        {services, #{
            party_management => "http://party-management:8022/v1/processing/partymgmt"
        }},
        {woody, #{
            % disabled | safe | aggressive
            cache_mode => safe,
            options => #{
                woody_client => #{
                    event_handler =>
                        {scoper_woody_event_handler, #{
                            event_handler_opts => #{
                                formatter_opts => #{
                                    max_length => 1000
                                },
                                events_severity => #{
                                    %% Was 'info'
                                    ['service handler result', error, business] => warning
                                }
                            }
                        }}
                }
            }
        }}
    ]},

    {snowflake, [
        % 1 second
        {max_backward_clock_moving, 1000},
        {machine_id, hostname_hash}
    ]},

    {prometheus, [
        {collectors, [default]}
    ]},

    {hackney, [
        {mod_metrics, woody_hackney_prometheus}
    ]},

    {progressor, [
        {defaults, #{
            storage => #{
                client => prg_pg_backend,
                options => #{
                    pool => default_pool
                }
            },
            retry_policy => #{
                initial_timeout => 5,
                backoff_coefficient => 2,
                max_timeout => 1800,
                max_attempts => 10,
                non_retryable_errors => []
            },
            task_scan_timeout => 15,
            process_step_timeout => 60
        }},

        {namespaces, #{
            invoice => #{
                processor => #{
                    client => hg_progressor,
                    options => #{
                        party_client => #{},
                        ns => <<"invoice">>,
                        handler => hg_machine
                    }
                },
                storage => #{
                    client => prg_pg_backend,
                    options => #{
                        pool => invoice_base_pool,
                        front_pool => invoice_front_pool,
                        scan_pool => invoice_scan_pool
                    }
                },
                worker_pool_size => 200
            },
            invoice_template => #{
                processor => #{
                    client => hg_progressor,
                    options => #{
                        party_client => #{},
                        ns => <<"invoice_template">>,
                        handler => hg_machine
                    }
                },
                worker_pool_size => 5
            },
            customer => #{
                processor => #{
                    client => hg_progressor,
                    options => #{
                        party_client => #{},
                        ns => <<"customer">>,
                        handler => hg_machine
                    }
                },
                worker_pool_size => 5
            },
            recurrent_paytools => #{
                processor => #{
                    client => hg_progressor,
                    options => #{
                        party_client => #{},
                        ns => <<"recurrent_paytools">>,
                        handler => hg_machine
                    }
                },
                worker_pool_size => 5
            }
        }}
    ]},

    %%
    {epg_connector, [
        {databases, #{
            hellgate_db => #{
                host => "db",
                port => 5432,
                database => "hellgate",
                username => "hellgate",
                password => "postgres"
            }
        }},
        {pools, #{
            default_pool => #{
                database => hellgate_db,
                size => {6, 12}
            },
            invoice_base_pool => #{
                database => hellgate_db,
                size => 52
            },
            invoice_front_pool => #{
                database => hellgate_db,
                size => {12, 72}
            },
            invoice_scan_pool => #{
                database => hellgate_db,
                size => 2
            }
        }}
    ]},

    {canal, [
        {url, "http://vault"},
        {engine, kvv2}
    ]}
].