syntax = "proto3";

package envoy.config.filter.http.fault.v2;

import "envoy/api/v2/route/route_components.proto";
import "envoy/config/filter/fault/v2/fault.proto";
import "envoy/type/percent.proto";

import "google/protobuf/wrappers.proto";

import "udpa/annotations/migrate.proto";
import "udpa/annotations/status.proto";
import "validate/validate.proto";

option java_package = "io.envoyproxy.envoy.config.filter.http.fault.v2";
option java_outer_classname = "FaultProto";
option java_multiple_files = true;
option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/filter/http/fault/v2;faultv2";
option (udpa.annotations.file_migrate).move_to_package = "envoy.extensions.filters.http.fault.v3";
option (udpa.annotations.file_status).package_version_status = FROZEN;

// [#protodoc-title: Fault Injection]
// Fault Injection :ref:`configuration overview <config_http_filters_fault_injection>`.
// [#extension: envoy.filters.http.fault]

message FaultAbort {
  // Fault aborts are controlled via an HTTP header (if applicable). See the
  // :ref:`HTTP fault filter <config_http_filters_fault_injection_http_header>` documentation for
  // more information.
  message HeaderAbort {
  }

  reserved 1;

  oneof error_type {
    option (validate.required) = true;

    // HTTP status code to use to abort the HTTP request.
    uint32 http_status = 2 [(validate.rules).uint32 = {lt: 600 gte: 200}];

    // Fault aborts are controlled via an HTTP header (if applicable).
    HeaderAbort header_abort = 4;
  }

  // The percentage of requests/operations/connections that will be aborted with the error code
  // provided.
  type.FractionalPercent percentage = 3;
}

// [#next-free-field: 14]
message HTTPFault {
  // If specified, the filter will inject delays based on the values in the
  // object.
  filter.fault.v2.FaultDelay delay = 1;

  // If specified, the filter will abort requests based on the values in
  // the object. At least *abort* or *delay* must be specified.
  FaultAbort abort = 2;

  // Specifies the name of the (destination) upstream cluster that the
  // filter should match on. Fault injection will be restricted to requests
  // bound to the specific upstream cluster.
  string upstream_cluster = 3;

  // Specifies a set of headers that the filter should match on. The fault
  // injection filter can be applied selectively to requests that match a set of
  // headers specified in the fault filter config. The chances of actual fault
  // injection further depend on the value of the :ref:`percentage
  // <envoy_api_field_config.filter.http.fault.v2.FaultAbort.percentage>` field.
  // The filter will check the request's headers against all the specified
  // headers in the filter config. A match will happen if all the headers in the
  // config are present in the request with the same values (or based on
  // presence if the *value* field is not in the config).
  repeated api.v2.route.HeaderMatcher headers = 4;

  // Faults are injected for the specified list of downstream hosts. If this
  // setting is not set, faults are injected for all downstream nodes.
  // Downstream node name is taken from :ref:`the HTTP
  // x-envoy-downstream-service-node
  // <config_http_conn_man_headers_downstream-service-node>` header and compared
  // against downstream_nodes list.
  repeated string downstream_nodes = 5;

  // The maximum number of faults that can be active at a single time via the configured fault
  // filter. Note that because this setting can be overridden at the route level, it's possible
  // for the number of active faults to be greater than this value (if injected via a different
  // route). If not specified, defaults to unlimited. This setting can be overridden via
  // `runtime <config_http_filters_fault_injection_runtime>` and any faults that are not injected
  // due to overflow will be indicated via the `faults_overflow
  // <config_http_filters_fault_injection_stats>` stat.
  //
  // .. attention::
  //   Like other :ref:`circuit breakers <arch_overview_circuit_break>` in Envoy, this is a fuzzy
  //   limit. It's possible for the number of active faults to rise slightly above the configured
  //   amount due to the implementation details.
  google.protobuf.UInt32Value max_active_faults = 6;

  // The response rate limit to be applied to the response body of the stream. When configured,
  // the percentage can be overridden by the :ref:`fault.http.rate_limit.response_percent
  // <config_http_filters_fault_injection_runtime>` runtime key.
  //
  // .. attention::
  //  This is a per-stream limit versus a connection level limit. This means that concurrent streams
  //  will each get an independent limit.
  filter.fault.v2.FaultRateLimit response_rate_limit = 7;

  // The runtime key to override the :ref:`default <config_http_filters_fault_injection_runtime>`
  // runtime. The default is: fault.http.delay.fixed_delay_percent
  string delay_percent_runtime = 8;

  // The runtime key to override the :ref:`default <config_http_filters_fault_injection_runtime>`
  // runtime. The default is: fault.http.abort.abort_percent
  string abort_percent_runtime = 9;

  // The runtime key to override the :ref:`default <config_http_filters_fault_injection_runtime>`
  // runtime. The default is: fault.http.delay.fixed_duration_ms
  string delay_duration_runtime = 10;

  // The runtime key to override the :ref:`default <config_http_filters_fault_injection_runtime>`
  // runtime. The default is: fault.http.abort.http_status
  string abort_http_status_runtime = 11;

  // The runtime key to override the :ref:`default <config_http_filters_fault_injection_runtime>`
  // runtime. The default is: fault.http.max_active_faults
  string max_active_faults_runtime = 12;

  // The runtime key to override the :ref:`default <config_http_filters_fault_injection_runtime>`
  // runtime. The default is: fault.http.rate_limit.response_percent
  string response_rate_limit_percent_runtime = 13;
}
