fastly

• Make HTTP guest caching compatible with send_async.

• Add PendingRequest::send_to_client method for handing off responsibility to the host for sending eventual responses to in-flight requests back to the client.

• Use LazyLock/OnceLock instead of lazy_static

• Support stale-if-error in the HTTP cache when using guest caching (default). See Fastly's documentation on stale-if-error for more details.

  The HTTP cache will now store and serve stale-if-error responses. The duration is configurable via Request::set_stale_if_error or CandidateResponse::set_stale_if_error. If you wish to disable this behavior, you can use Request::set_stale_if_error(Duration::ZERO) to avoid storing any cache entries with a stale-if-error period.

  If the HTTP cache has a response in its stale-if-error period and if Request::send or Request::send_async would otherwise return a SendError instead of a Response, Request::send and Request::send_async will instead provide the cached response. For the request collapse leader, Response::masked_error returns the error that would otherwise have been returned.

  Note that 5xx responses from a server are not, by default, replaced with a stale-if-error response. You can override this behavior by returning an error from the after_send cache hook.

• Adjust the documentation around the for_grpc flag on backends to note current requirements and stability levels.
• Add allowed_malformed_query_params as an option for Image Optimizer requests.

• Surrogate-Control and Surrogate-Key headers are preserved for shielded requests.
• Interfaces for reusable sandboxes have been moved from the fastly::experimental::reusable_sessions module to fastly::http::serve.
• Added new bot detection methods to Request.
• Removed the deprecated write_bytes and write_str methods for HTTP bodies, in favor of std::io::Write trait methods.
• Dynamic backends now have a 200 max_connections limit by default (previously unlimited), matching the default limit for static backends.
• The following Request methods now return Result, rather than panicking on buffer size or UTF-8 decoding errors:
  • get_original_header_names
  • get_tls_raw_client_certificate
  • get_tls_cipher_openssl_name
  • get_tls_protocol
• Added the fastly::http::body::StreamingBody::abandon method to explicitly abandon a stream.
• Dropping an unfinished StreamingBodyHandle will now abandon the stream.
• Added a new SendErrorCause::Http2StreamError variant, containing more details about unexpected HTTP/2 error responses.
• FastlyStatus is now marked as #[must_use].
• Removed the deprecated fastly::cache::core::Found::ttl method.
• Clarified how calling Request::set_pass affects other cache override options.
• Documented that Request::send_async and Request::send_async_streaming will fail if called after setting a before_send or after_send callback.
• Improved the documentation for Image Optimizer functionality.

• Add fastly::compute_runtime::get_heap_mib for reading memory usage
• Add fastly::experimental::reusable_sessions::Serve for using a callback handler when reusing sandboxes.
• Explicitly register max_connections as 0 even when BackendBuilder is not provided a value for it.

• Add support to BackendBuilder for configuring prefer_ipv6 and additional keepalive options
• Include wasm32-wasip2 target for docs.rs builds
• Cleanup examples in documentation to not suggest using unwrap

• Add support for sending 103 Early Hints to downstream clients
• Add sandbox_id() function

• Document KV store list limits
• Fix issue when using Request::with_image_optimizer that sometimes resulted in invalid argument errors.
• Fix warnings when compiling with newer Rust releases
• Update documentation for fastly::experimental::reusable_sessions
• Fix links for Shield::with_first_byte_timeout

• Add first_byte_timeout to shield backends

  Every backend has a "first-byte timeout". This timeout applies to the HTTP response line and response headers. If the client (Compute instance) does not receive all the HTTP headers within the first-byte timeout, the Compute platform considers the request failed and returns a SendError (with e.g. SendErrorCause::HttpResponseTimeout) to the instance.

  By default, all backends have a first-byte timeout of 15 seconds. This timeout is configurable for static and dynamic backends; however, it was previously not configurable for shield backends. If a shield POP took more than 15 seconds to complete writing its response headers, the Compute instance at the edge POP would receive a SendError.

  This release adds Shield::with_first_byte_timeout, which creates a copy of the Shield with the first-byte timeout configured. Backends created from the resulting Shield (i.e. Shield::encrypted_backend, Shield::unencrypted_backend) will use the configured first-byte timeout.

• Add new InspectError variants

• Request hooks: clarify that before_send and after_send are not invoked if the result is explicitly passed to origin (set_pass)
• HTTP cache override: document that the cache override key must be exactly 32 bytes long
• Pass backend name at the start of HTTP cache transactions, to improve accuracy of POP-local / global cache hit ratio metrics.
• Add Device::is_bot method for indicating when a User-Agent was recognized as a bot
• Add the rest of the Device fields getter functions to access each subfield
• Add InspectConfig::from_request and InspectConfig::from_handles for creating new configurations for use with fastly::security::inspect.
• Deprecate InspectConfig::new in favor of choosing one of the new from_* constructors
• Add Request::get_tls_client_servername for getting SNI sent by client
• Fix serialization for threshold value in Image Optimization
• Optimize conversions for IP addresses and header values for hostcalls

• Request metadata: use per-handle calls, rather than global calls, for most metadata.
• SendErrorCause::DestinationNotFound is now returned when a request is sent to an invalid backend, instead of SendErrorCause::InternalError.
• Clarified that Request::get_content_type can panic if the Content-Type header contains an invalid MIME type.
• Added Body::known_length to get the length of a body if it is known.
• Clarified that manually-configured cipher suites only apply to TLS 1.0 - 1.2 connections.
• Request::get_client_ip_addr/Request::get_server_ip_addr now return None for downstream requests without IPs
• Experimental: added support for processing multiple requests sequentially in a session.

• Core cache API: Opt-in to use ranges when streaming

  The core cache API allows for cache items to be concurrently streamed to / from the cache. If:

  • The size of the cached item's body was not provided by the writer
  • The reader requests a specific range of the cached item's body (to_stream_from_range)
  • The writer and reader are concurrent, i.e. the body is streamed from one to the other the core cache API will ignore the requested range and provide the whole body. There is no explicit notification that the whole body is provided instead of a range.

  In this SDK release, this remains the default behavior. However, lookup types (LookupBuilder, TransactionLookupBuilder, ReplaceBuilder) now offer an always_use_requested_range option. If set, body reads conducted as part of this lookup/transaction/replacement will always use the requested range, even when streaming.

  In a future (major) SDK release, the default behavior will change to always_use_requested_range.

• Core cache API: Explicit check of inherently invalid ranges

  The core cache API (to_stream_from_range) will now explicitly reject ranges where the start is strictly after the end. (Note that start and end are inclusive, so start == end identifies a valid 1-byte range.)

• Config store: Allow config store values larger than 8k

  Config store values can potentially be larger than 8k characters. The default limit is still 8k, but customers can now be individually assigned a larger limit (up to 32k).

  This change updates the Rust SDK so that it resizes config store buffer on BUFLEN error, instead of returning an error. The default initial buffer length is 256.

• Core cache API: Clarify TTL vs. max_age

  TTL and max_age are two distinct concepts. Max age gives the age of an item when it becomes stale; TTL is not long from the current point in time until that age is reached.

  The core cache API used the term ttl in several places to refer to the max-age value. In this version, we deprecate these ttl methods (without changing their semantics), and add ttl_remaining and max_age methods to provide clearer semantics.

• Image Optimizer: provide a clearer error when Image Optimizer is not enabled for a service

• Core cache API: documentation improvements

• Improve the documentation for to_stream_from_range
• Promote shielding support from the experimental tree into the main module.

• Added experimental support for shielding primitives. See the documentation in the fastly::experimental::shielding module for more information.
• Fixed small issues in an ACL and a geolocation example, as well as a typo in the KV store documentation.
• Expanded and clarified our documentation regarding the validation of server certificates using dynamic backends.
• Clarified our documentaton on streaming bodies.
• Added append_vary and push_vary methods to CandidateResponse, and add further documentation.
• Code cleanups in the security module, including the ability to set the buffer size for the inspection server's response (buffer size defaults to 16KB).

• Updated fastly::kv_store documentation
• Updated hashbrown crate to 0.15.2
• Updated url crate to 2.5.4

• Fixed bug with fetching generation information from the KV store
• Added support for using Fastly ACLs in the acl module
• Added a privileged option to caching APIs for Fastly-internal services running on Compute.

• New HTTP caching APIs, including set_cache_key, set_before_send, and set_after_send on Request. These allow for deep customization of caching behavior. The set_after_send method in particular sets up a callback to be invoked after receiving a backend response, but before caching it -- allowing cache configuration to be driven by the response data, and for the response to be modified prior to caching.
• As part of that new caching API, caching hews a bit closer to the HTTP spec. Where previously a response containing the string private or no-store anywhere in the relevant cache control header would not be cached, the new API looks for private and no-store as standalone entries in the header, which is the more typical behavior. The previous behavior can be emulated by using the new set_after_send hook.
• Refactored internals to reduce unnecessary copying. This required one minor public API change, to Request::get_url_mut, which now returns a smart pointer rather than a direct &mut reference.
• inspect and related types have been been moved from the experimental module to security
• KV store API overhaul, which includes new builder-style APIs with a much richer set of options
• Further improvements for lazily loading and cloning HTTP headers

• Added support for configuring HTTP and TCP keepalive parameters on dynamic backends.
• Added APIs for replacing existing objects in the cache with new content
• Updated documentation for the experimental::inspect and associated types

• Added support for lazily loading and cloning HTTP headers
• Added get_vcpu_ms hostcall that returns the amount of vCPU milliseconds that the guest has been running.

• Added support for Rust 1.80.0

• Added Response::get_backend_addr to get the IP and port that received a direct pass request.
• Added InsertBuilder::deliver_node_max_edge, TransactionInsertBuilder::deliver_node_max_edge, and TransactionUpdateBuilder::deliver_node_max_edge, which allows configuring the maximum time the cached item may live on a deliver node in a POP.

Added

• Added PendingTransaction to allow code to run while waiting for request collapsing.
• Added TransactionLookupBuilder::execute_async to get access to PendingTransaction.
• Added Request::get_server_ip_addr to get the IP address on which this server received the HTTP request.

Deprecated

• Deprecated uap_parse.

Changed

• Updated http crate to 1.1.0, which changes some of the types re-exported from this crate such as fastly::http::HeaderValue. If your application has an explicit dependency on the http crate, you may need to update that dependency as well in order to interact with the fastly crate.
• Usage of the handoff_websocket and handoff_fanout methods on Request and RequestHandle is no longer considered experimental. The RequestUpgradeWebsocket and RequestHandleUpgradeWebsocket traits are no longer required to use these functions, and the trait methods have been marked as deprecated.
• Conversion functions between low-level handles and Request and Response no longer return errors following the removal of the limits module.
• Response::with_header() has been changed to have appending behavior rather than set behavior. As a result, chained invocations of with_header() will add multiple values for the same header to the response, just like Response::append_header(). Users that prefer the old behavior should use Response::with_set_header(), instead.

Deprecated

• Deprecated write_bytes() and write_str() methods on Body and StreamingBody in favor of std::io::Write methods.

Removed

• Removed the previously-deprecated limits module. Fastly's network services resource limits do and will continue to apply.
• Removed Request::try_from_client(), which is no longer useful following the removal of the limits module.
• Removed the previously-deprecated Object Store items that have been renamed to KV Store.
• Removed the previously-deprecated TransactionUpdateBuilder::sensitive_data() method.
• Removed several previously-deprecated variants of SendErrorCause in favor of new, more-specific variants.
• Removed the previously-deprecated BackendExt::builder() trait method in favor of the Backend::builder() method.
• Removed the previously-deprecated write_bytes() and write_str() methods for BodyHandle and StreamingBodyHandle in favor of std::io::Write methods.

Added

• Added Secret::try_plaintext() to allow explicit handling of Secret Store decryption failures.

Changed

• Improved the clarity of some docstrings.

Fixed

• Fixed Request::get_tls_raw_client_certificate() so that it returns None when the client has not provided a client certificate. It previously returned Some("") in this case.
• Fixed Request::get_tls_raw_client_certificate_bytes() so that it returns None when the client has not provided a client certificate. It previously returned Some(&[]) in this case.
• Fixed a bug in BackendBuilder that caused BackendCreationError::HostError(FastlyStatus::INVAL) to be returned in rare circumstances when a valid client certificate was set.
• Fixed behavior of some _str() variants of header methods that could cause panics when header values contained valid UTF-8 but not valid ASCII bytes.

Added

• Added support for getting JA4 information from Request objects
• Added support for using Edge Rate Limiting (ERL) within Compute
• Added asynchronous versions of the KV store delete operation

Deprecated

• Deprecated the limits module. Fastly's network services resource limits do and will continue to apply.
• Deprecated the TransactionUpdateBuilder::sensitive_data method

Added

• Added support for interacting with trailers; see the BodyExt trait in experimental for details.

Changed

• Fixed Request::clone_with_body and Response::clone_with_body trailer support.

Added

• Added asynchronous versions of the KV store lookup and insert operations.
• Added fastly::device_detection::lookup.

Changed

• JA3 accessors for non-TLS connections now return None rather than panicking.

• Updated hcd is_healthy error message when backend not found.

• Renamed Compute@Edge to Compute.

• Added support for interacting with trailers; see the BodyExt trait in experimental for details.

• Fixed Request::clone_with_body and Response::clone_with_body trailer support.

Added

• Added a flag to indicate that gRPC support is required for a dynamic backend.
• Added a number of new variants to SendErrorCause, providing better visibility into the ways that sending an HTTP request and receiving an HTTP response can fail.
• Added _bytes variants of methods to get client request TLS metadata, e.g. Request::get_tls_raw_client_certificate_bytes, so that non-UTF-8 metadata can be procssed without panics.
• Added accessors for a fingerprint of the client request's original headers.

Changed

• Changed the Debug output for FastlyStatus, making it more clear when those values are appearing in higher-level errors.

Deprecated

• Deprecated several variants of SendErrorCause in favor of new, more-specific variants.

Fixed

• Removed a prematurely-released interface change that caused link errors in 0.9.6.

Added

• Added support for mTLS / client certificates in dynamic backend definitions.
• Added [Request::make_request_handle].
• Added config-store-specific raw functions in fastly-sys.

Deprecated

• Deprecated the original redirect_to_websocket_proxy and redirect_to_grip_proxy in fastly-sys, in favor of their v2 versions: redirect_to_websocket_proxy_v2 and redirect_to_grip_proxy_v2.

Added

• Added the Compute Simple Cache API in fastly::cache::simple.
• fastly::error now includes a reëxport of anyhow::Context in addition to anyhow::Error.
• Added fastly::secret_store::Secret::from_bytes() to create unencrypted Secrets from bytes at runtime for compatibility with APIs that require a Secret.

Added

• Added the Compute Core Cache API in fastly::cache::core.

Changed

• Usage of Backend::builder is no longer considered experimental. The BackendExt trait is no longer required to use that function, and the trait function has been marked as deprecated.

Deprecated

• Deprecated BackendExt::builder in favor of a native Backend::builder function.

Added

• Request::get_client_request_id() returns an identifier for the current client request.

Changed

• Renamed Object Store to KV Store, and deprecated the previous names.
• The std::io::Write implementations for BodyHandle and StreamingBodyHandle no longer panic upon error.

Deprecated

• Deprecated the old Object Store items that have been renamed to KV Store.
• Deprecated write_bytes() and write_str() methods for BodyHandle and StreamingBodyHandle in favor of std::io::Write methods.

Added

• Added various methods to Backend to access various configuration settings.

Changed

• Adjusted documentation for BackendBuilder::override_host.
• Added examples to the module-level limits documentation.
• Bumped bytes dependency

Fixed

• Updated documentation for Response::stream_to_client(), Request::send_async_streaming(), and RequestHandle::send_async_streaming() to show that streaming bodies must be finish()ed, not dropped.
• Secret store: BUFLEN error when the plaintext secret's length is greater than 599 bytes

Fixed

• Fixed warnings for unused internal items.

Added

• Added a new fastly::secret_store module for use with the new Fastly Secret Store.
• Added support for enabling or disabling reuse of connections for the experimental dynamic backend interface. The default is to reuse connections. Connection reuse is at the discretion of the server running the service.

Changed

• Streaming bodies must now be explicitly finish()ed in order to be properly framed. The default behavior on drop for StreamingBody or StreamingBodyHandle now can yield an error to the recipient of the message (the client requesting the response, or the backend receiving a request). This is a breaking change for all current uses of these types, and prevents situations where errors or premature exits from Compute programs could cause incomplete transfer-encoding: chunked bodies to appear complete despite being truncated.
• Request::with_header() has been changed to have appending behavior rather than set behavior. As a result, chained invocations of with_header() will add multiple versions of the same header to the request, just like Request::append_header(). Users that prefer the old behavior should use Request::with_set_header(), instead.
• Documentation on backend creation has been extended, to make it clear how to tell if a service supports dynamic backends.
• The arguments to BackendBuilder::new and BackendBuilder::override_host have ben standardized to impl ToString, to match the other functions in the file.
• LookupError and OpenError enums for config stores are now #[non_exhaustive].
• Improved error messages when some resource limits are exceeded.

Removed

• Removed the migration guide Rustdoc for SDKs earlier than 0.6.0.
• Removed deprecated aliases from Request, RequestHandle, and Response.
• Removed the deprecated legacy items from fastly-sys.
• Removed deprecated aliases from fastly-shared.

Fixed

• Fixed a warning about an unused function.

Added

• Added Request::get_tls_raw_client_certificate, which returns the client's mutual TLS certificate.
• Added Request::get_tls_client_cert_verify_result, which returns an error code if applicable.
• Added an experimental Request::handoff_websocket interface, which hands off a WebSocket request to a backend.
• Added an experimental Request::handoff_fanout interface, which passes a request to the Fanout GRIP proxy.

Changed

• Deprecated the experimental RequestUpgradeWebsocket::upgrade_websocket trait method.

Fixed

• Fixed some documentation misspellings.
• Added an http::purge module, containing interfaces to purge surrogate keys. This was previously listed in the changelog of 0.8.7, but was not actually included in the release.

Added

• Added Backend::is_healthy() to experimental module
• Added get_client_h2_fingerprint to Request and client_h2_fingerprint to RequestHandle to get the HTTP/2 fingerprint of a client request if available
• Added an interface to the Compute Object Store.
• Added interfaces to issue surrogate key purges.

Changed

• Improved deprecation messages for renaming of Dictionary to ConfigStore
• Fixed some misspellings.

Added

• Added an experimental dynamic backend interface.

Changed

• Renamed Dictionaries to Config Stores, and deprecated the previous names.

Added

• Added get_headers() methods to Request and Response which return an iterator over all header values.
• Added Request::get_tls_ja3_md5() for getting the JA3 hash of the TLS ClientHello message.
• Added experimental WebSocket upgrade interface.

Added

• Added set_framing_headers_mode and with_framing_headers_mode methods to Request and Response, which allow you to manually control the Content-Length and Transfer-Encoding headers sent for a request or a response.

Changed

• Switched to Rust 2021 edition, so the minimum supported Rust version is now 1.56.0.

Added

• Added Body::try_get_prefix_mut to allow handling I/O errors when reading a body prefix.

Added

• Added a set of *_str_lossy() accessors for HTTP headers and bodies. Unlike the *_str methods, they do not panic if the values contain invalid UTF-8, but may perform allocation to insert replacement characters for invalid sequences.

Fixed

• Fixed a crash when using Request::clone_with_body().

Added

• Added a OpenError::DictionaryDoesNotExist error variant, which identifies when a dictionary couldn't be found.
• Added Dictionary::try_open(), which returns a Result<Dictionary, OpenError>, allowing programs to explicitly handle open failures.
• Added automatic gzip decompression for backend responses; see Request::set_auto_decompress_gzip().
• Added Request::get_query_parameter() for easy access to individual query parameter strings.
• Added get_ttl() and get_stale_while_revalidate() accessors for CacheOverride.

Changed

• Renamed with_body_bytes() and set_body_bytes() methods to with_body_octet_stream() and set_body_octet_stream() to emphasize that they modify the Content-Type of the request or response. The original names are still present, but deprecated.
• When reading from an HTTP body, an unexpected EOF (e.g., if a backend disconnects) results in an appropriately-tagged std::io::Error rather than the generic "fastly_http_body::read failed".

Fixed

• Panics caused when request limits are exceeded in Request::from_client() or the #[fastly::main] macro now log a more informative error message; previously it was reported as panicked at 'explicit panic'.

Added

• Added Dictionary::try_get, which returns a Result<String, LookupError>, allowing programs to explicitly handle lookup failures.
• Added an Other variant to dictionary::LookupError.
• Added close to RequestHandle, and ResponseHandle.
• Added the non_exhaustive enums HandleError and HandleKind for the low level handle interface.
• Added Satellite and UltraBroadband variants for ConnSpeed and ConnType in the geolocation interface.
• Added Other variants for ConnSpeed, ConnType, Continent, ProxyDescription, and ProxyType in the geolocation interface for cases where the geolocation database contains variants that are newer than the current SDK definitions.

Fixed

• Fixed geolocation calls returning no data when only partial data was available for a requested IP address.

Changed

• The Minimum Supported Rust Version (MSRV) for the fastly crate is now 1.54.0.
• BodyHandle::close now works for non-streaming bodies in addition to the already-closeable streaming bodies.
• BodyHandle, RequestHandle and ResponseHandle now call close as part of their Drop implementation when they go out of scope, saving a small amount of leaked memory for services that make multiple HTTP requests.
• Exported unsafe low-level interfaces for creating BodyHandles.
• The functions is_valid and is_invalid are now const for BodyHandle, RequestHandle, and ResponseHandle
• Geo::utc_offset now returns Option<time::UtcOffset> instead of Option<chrono::FixedOffset>.
• ConnSpeed, ConnType, ProxyDescription, and ProxyType are now non_exhaustive.
• Exported the fastly::dictionary module. Its exported types Dictionary and LookupError remain accessible through other paths, but this module provides a way to import them together.

Removed

• Removed Copy from ConnSpeed, ConnType, Continent, ProxyDescription and ProxyType inside the geo module; their new Other variants contain an arbitrary String which is not Copyable. The strings the Other variant might contain are small, so these enums (and Geo itself) can be efficiently cloned.

Fixed

• Removed the use of an unstable documentation feature that caused the docs.rs documentation build to fail.

Added

• Added an experimental API for controlling the cache keys used for requests. Note that experimental APIs are subject to change or removal even in minor versions of the SDK.
• Added two new error causes to SendErrorCause: HeadTooLarge and InvalidStatus. Previously these would be part of the Invalid variant, but now have their own to provide more insight as to what went wrong. In particular you will now know when a response fails due to an invalid status, such as HTTP/1.1 42 MadeUpStatus or if the response header was too large.

Fixed

• Fixed a typo in a panic message inside of fastly::handle::dictionary::DictionaryHandle::open.

Fixed

• Fixed the buffer sizes reported in BufferSizeErrors incorrectly reporting the initial buffer size rather than the maximum size the buffer can grow to. The maximum buffer size was still being used, but the error field was misleading.

• Dropped the unused dependency on log. See log-fastly for the recommended high-level logging interface.

Added

• Added with_body_text_plain(), set_body_text_plain(), with_body_text_html(), set_body_text_html() convenience methods which set the body contents along with their respective content types.
• Added Response::see_other, Response::redirect, and Response::temporary_redirect builders to support building a redirect response and its Location header all at once.
• Added SendError::root_cause and SendErrorCause to describe specific upstream request failure causes.

Deprecated

• Deprecated with_body_str() and set_body_str() methods in favor of with_body_text_plain() and set_body_text_plain().

Changed

• RequestHandle::send, RequestHandle::send_async, and Requestandle::send_async_streaming now return a specific SendErrorCause on errors, replacing an anyhow::Error.
• select_handles now returns a specific SendErrorCause on errors, replacing an anyhow::Error.
• PendingRequestHandle::poll and PendingRequestHandle::wait now return a specific SendErrorCause on errors, replacing an anyhow::Error.

Added

• Added Dictionary::contains and DictionaryHandle::contains methods, which allow programs to check if a key exists in a Fastly Edge Dictionary.

Changed

• Made a broad-ranging overhaul to the Request and Response APIs. See the documentation of the fastly crate for details and a migration guide.

Changed

• Added an upper bound to the fastly-sys dependency to avoid conflicts with newer fastly-sys versions. We expect to address this by fixing fastly-sys semantic versioning in the future.

Added

• Added fastly::dictionary::Dictionary, which allows programs to look up values in Fastly Edge Dictionaries.

• Added set_pci method to fastly::request::RequestExt and pci to fastly::request::RequestBuilderExt, which both prevent cached content subject to compliance rules from being written to non-volatile storage.

• Added set_surrogate_key to fastly::request::RequestExt and surrogate_key to fastly::request::RequestBuilderExt. These allow surrogate keys to be added to cached content so that content may be purged in groups.

• Added fastly::geo::Continent::as_code() for easy access to two-letter continent codes.

Changed

• fastly::request::RequestExt now offers cache_override and cache_override_mut as accessors to a Request's CacheOverride instead of the get_ and set_ pair.

Fixed

• Fixed a FixedOffset::east() panic that could arise when handling geoip data when the geographic data for the IP address is invalid.

Added

• Added get_header_value method to fastly::request::RequestHandle.

• Added specific error types for some API calls:

  • fastly::error::SendError is returned by APIs that send backend requests. Note that the common case for a failed request remains an Ok result with a 5xx status code response.
  • fastly::error::BufferSizeError is returned by handle API calls that can fail due to an insufficient buffer size.

• Added RequestExt::send_async_streaming() and RequestHandle::send_async_streaming(), which allow programs to continue writing bytes to upstream request bodies after the headers have been sent.

• Added Backend::name() to get the string representation of a backend.

• Added ResponseExt::backend() to retrieve the Backend a response came from.

• Added ResponseExt::backend_request() and ResponseExt::take_backend_request() to retrieve the Request that this response was returned from, minus the body which is consumed when the request is sent. The take variant takes ownership of the Request so that it can be subsequently reused for another backend request.

• Added PendingRequest::sent_req() to retrieve the Request that was sent, minus the body which is consumed when the request is sent.

Changed

• Removed Result return types from various functions and methods. Internal errors will now cause a panic. This primarily impacts the Body, BodyHandle, RequestHandle, and ResponseHandle types. This helps remove noise from ? operators in cases where user programs cannot realistically recover from the error.

• get_header_value methods for RequestHandle and ResponseHandle will now return Ok(None) if the header does not exist, rather than an empty header.

• Response::send_downstream() and ResponseHandle::send_downstream() now begin sending the responses immediately, rather than when the program exits.

• Renamed Backend::new() to Backend::from_name(), and deprecated the old name.

Deprecated

• Deprecated Backend::new() in favor of Backend::from_name().

Removed

• Removed fastly::abi submodule from the public interface.

• Removed impl From<PendingRequestHandle> for PendingRequest, as PendingRequests now must be build with the backend Request they were sent with.

Added

• Added Drop implementations for streaming bodies to close streaming responses when the associated StreamingBodyHandle or StreamingBody goes out of scope. This allows client requests to finish while the Compute program is still running.

• Added downstream_original_header_count, which gets the original number of headers of the downstream request.

• Added ResponseHandle::remove_header and RequestHandle::remove_header, which can remove headers directly from handles.

Changed

• Separated the low-level Compute bindings into a new, separately-versioned crate, in order to reduce the frequency of breaking changes for users of the fastly crate.