Sharing data between filters
Envoy provides the following mechanisms for the transfer of configuration, metadata and per-request/connection state to, from and between filters, as well as to other core subsystems (e.g., access logging).
Static state is any immutable state specified at configuration load time (e.g., through xDS). There are three categories of static state:
Several parts of Envoy configuration (e.g. listeners, routes, clusters) contain a metadata where arbitrary key-value pairs can be encoded. The typical pattern is to use the filter names in reverse DNS format as the key and encode filter specific configuration metadata in the value. This metadata is immutable and shared across all requests/connections. Such config metadata is usually provided during bootstrap time or as part of xDS. For example, weighted clusters in HTTP routes use the metadata to indicate the labels on the endpoints corresponding to the weighted cluster. Another example, the subset load balancer uses the metadata from the route entry corresponding to the weighted cluster to select appropriate endpoints in a cluster
Metadata as such is untyped. Before
acting on the metadata, callers typically convert it to a typed class
object. The cost of conversion becomes non-negligible when performed
repeatedly (e.g., for each request stream or connection). Typed Metadata
solves this problem by allowing filters to register a one time conversion
logic for a specific key. Incoming config metadata (via xDS) is converted
to class objects at config load time. Filters can then obtain a typed
variant of the metadata at runtime (per request or connection), thereby
eliminating the need for filters to repeatedly convert from
ProtobufWkt::Struct to some internal object during request/connection
For example, a filter that desires to have a convenience wrapper class over
an opaque metadata with key
register a factory
ServicePolicyFactory that inherits from
ClusterTypedMetadataFactory. The factory translates the
into an instance of
ServicePolicy class (inherited from
FilterState::Object). When a
Cluster is created, the associated
ServicePolicy instance will be created and cached. Note that typed
metadata is not a new source of metadata. It is obtained from metadata that
is specified as part of the configuration. A
serializeAsProto method can be configured in access loggers to log it.
HTTP Per-Route Filter Configuration
In HTTP routes, typed_per_filter_config allows HTTP filters to have virtualhost/route-specific configuration in addition to a global filter config common to all virtual hosts. This configuration is converted and embedded into the route table. It is up to the HTTP filter implementation to treat the route-specific filter config as a replacement to global config or an enhancement. For example, the HTTP fault filter uses this technique to provide per-route fault configuration.
typed_per_filter_config is a
map<string, google.protobuf.Any>. The Connection
manager iterates over this map and invokes the filter factory interface
createRouteSpecificFilterConfigTyped to parse/validate the struct value and
convert it into a typed class object that’s stored with the route
itself. HTTP filters can then query the route-specific filter config during
Dynamic state is generated per network connection or per HTTP stream. Dynamic state can be mutable if desired by the filter generating the state.
Envoy::Http::Filter provide a
StreamInfo object that contains information about the current TCP
connection and HTTP stream (i.e., HTTP request/response pair)
StreamInfo contains a set of fixed attributes as part of
the class definition (e.g., HTTP protocol, requested server name, etc.). In
addition, it provides a facility to store typed objects in a map
map<string, FilterState::Object>). The state stored per filter can be
either write-once (immutable), or write-many (mutable).
Filter state sharing
Filter state objects are bound to the lifespan of the associated parent stream. However, by marking a downstream object as shared with the upstream connection during creation, the object is shared with the upstream connection filter state, and its lifespan is extended beyond the original stream. Any upstream TCP or HTTP filter can access the shared object. Upstream transport sockets can also read the shared objects and customize the creation of the upstream transport. For example, the internal upstream transport socket copies references to the shared objects to the internal connection downstream filter state.
The filter state objects that are shared with the upstream also affect the connection pooling decisions if they implement a hashing interface. Whenever a shared hashable object is added, an upstream connection is created for each distinct hash value, which ensures that these objects are not overwritten by subsequent downstream requests to the same upstream connection. For example, a custom HTTP filter may create a shared hashable object from the value of a special header. In this case, a separate upstream connection is created for each distinct special header value, so that no two requests with different header values share an upstream connection. The same procedure applies to each shared hashable object individually, creating a combination matrix of the upstream connections per distinct combination of the object values.