Skip navigation links
  • Overview
  • Package
  • Class
  • Tree
  • Deprecated
  • Index
  • Help

Deprecated API

Contents

  • Interfaces
  • Classes
  • Exceptions
  • Fields
  • Methods
  • Constructors
  • Deprecated Interfaces
    Interface
    Description
    io.servicetalk.buffer.api.BufferHolder
    This API is going to be removed in future releases with no planned replacement. If it cannot be removed from your application, consider copying it into your codebase.
    io.servicetalk.client.api.internal.DefaultPartitionedClientGroup.PartitionedClientFactory
    We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
    io.servicetalk.client.api.internal.RequestConcurrencyController
    This interface is not used by ServiceTalk internal code anymore and will be removed in the future releases. If you depend on it, consider replicating this implementation in your codebase or reach out to us explaining the use-case.
    io.servicetalk.client.api.internal.ReservableRequestConcurrencyController
    This interface is not used by ServiceTalk internal code anymore and will be removed in the future releases. If you depend on it, consider replicating this implementation in your codebase or reach out to us explaining the use-case.
    io.servicetalk.client.api.partition.PartitionAttributes
    We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
    io.servicetalk.client.api.partition.PartitionAttributesBuilder
    We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
    io.servicetalk.client.api.partition.PartitionedServiceDiscovererEvent
    We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
    io.servicetalk.client.api.partition.PartitionMap
    We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
    io.servicetalk.client.api.partition.PartitionMapFactory
    We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
    io.servicetalk.concurrent.api.GroupedPublisher.QueueSizeProvider
    Use Publisher.groupBy(Function, int) instead.
    io.servicetalk.concurrent.api.ScanWithLifetimeMapper
    Use ScanLifetimeMapper.
    io.servicetalk.concurrent.api.ScanWithMapper
    Use ScanMapper.
    io.servicetalk.encoding.api.ContentCodec
    Use BufferEncoder and BufferDecoder.
    io.servicetalk.grpc.api.GrpcRoutes.AllGrpcRoutes
    This class is not used starting from version 0.42.0 (see PR#1893), we plan to remove it in future releases. In case you have a use-case, let us know.
    io.servicetalk.grpc.api.GrpcSerializationProvider
    Serialization is now specified via MethodDescriptor. Compression is configured per route. gRPC framing is internalized in the gRPC implementation.
    io.servicetalk.grpc.api.GrpcServiceFilterFactory
    gRPC Service Filters will be removed in future release of ServiceTalk. We encourage the use of StreamingHttpServiceFilterFactory and if the access to the decoded payload is necessary, then performing that logic can be done in the particular service implementation. Please use HttpServerBuilder.appendServiceFilter(StreamingHttpServiceFilterFactory) upon the builder obtained using GrpcServerBuilder.initializeHttp(GrpcServerBuilder.HttpInitializer) if HTTP filters are acceptable in your use case.
    io.servicetalk.http.api.ClientInvoker
    There is no use of this interface in our codebase, it will be removed in the future releases. If you depend on it, consider replicating a similar interface in your codebase.
    io.servicetalk.http.api.HttpApiConversions.ServiceAdapterHolder
    this interface is not needed anymore and will be removed in a future version with no replacement.
    io.servicetalk.http.api.HttpDeserializer
    Use HttpDeserializer2 or HttpStreamingDeserializer.
    io.servicetalk.http.api.HttpSerializationProvider
    Use HttpSerializers, HttpSerializer2, HttpDeserializer2, HttpStreamingSerializer, and HttpStreamingDeserializer.
    io.servicetalk.http.api.HttpSerializer
    Use HttpSerializer2 or HttpStreamingSerializer.
    io.servicetalk.http.api.PartitionedHttpClientBuilder
    We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
    io.servicetalk.http.api.PartitionHttpClientBuilderConfigurator
    Use PartitionedHttpClientBuilder.SingleAddressInitializer.
    io.servicetalk.http.netty.RetryingHttpRequesterFilter.DelayedRetry
    Use DelayedRetryException instead.
    io.servicetalk.http.utils.TimeoutFromRequest
    In areas which require TimeoutFromRequest use variants that accept BiFunction<HttpRequestMetaData, TimeSource, Duration>. E.g.: TimeoutHttpRequesterFilter(BiFunction, boolean), TimeoutHttpServiceFilter(BiFunction, boolean) for filters.
    io.servicetalk.loadbalancer.RoundRobinLoadBalancerBuilder
    use LoadBalancerBuilder interfaces instead.
    io.servicetalk.loadbalancer.RoundRobinLoadBalancerBuilderProvider
    use the LoadBalancerBuilder implementations along with LoadBalancerBuilderProvider
    io.servicetalk.serialization.api.SerializationProvider
    General Type serialization is not supported by all serializers. Defer to your specific Serializer implementation.
    io.servicetalk.serialization.api.Serializer
    Use the following types:
    • Serializer
    • StreamingSerializer
    • Deserializer
    • StreamingDeserializer
    io.servicetalk.serialization.api.StreamingDeserializer
    Use StreamingDeserializer.
    io.servicetalk.serialization.api.StreamingSerializer
    Use StreamingSerializer.
    io.servicetalk.transport.api.ConnectionAcceptor
    use LateConnectionAcceptor instead.
    io.servicetalk.transport.api.ConnectionAcceptorFactory
    use LateConnectionAcceptor instead.
    io.servicetalk.transport.netty.internal.SplittingFlushStrategy.FlushBoundaryProvider
    This interface will be removed in the future releases.
  • Deprecated Classes
    Class
    Description
    io.servicetalk.client.api.internal.DefaultPartitionedClientGroup
    We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
    io.servicetalk.client.api.internal.IgnoreConsumedEvent
    This class is not used by ServiceTalk internal code anymore and will be removed in the future releases. If you depend on it, consider replica ting this implementation in your codebase.
    io.servicetalk.client.api.internal.partition.DefaultPartitionAttributesBuilder
    We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
    io.servicetalk.client.api.internal.partition.PowerSetPartitionMap
    We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
    io.servicetalk.client.api.internal.partition.PowerSetPartitionMapFactory
    We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
    io.servicetalk.client.api.internal.RequestConcurrencyControllers
    This class is not used by ServiceTalk internal code anymore and will be removed in the future releases. If you depend on it, consider replicating this implementation in your codebase.
    io.servicetalk.client.api.internal.ReservableRequestConcurrencyControllers
    This class is not used by ServiceTalk internal code anymore and will be removed in the future releases. If you depend on it, consider replicating this implementation in your codebase.
    io.servicetalk.concurrent.internal.ArrayUtils
    This internal class will be removed in the future releases without a replacement. If you depend on it, consider copying into your codebase.
    io.servicetalk.concurrent.internal.ConcurrentTerminalSubscriber
    This internal class will be removed in the future releases without a replacement. If you depend on it, consider copying into your codebase.
    io.servicetalk.concurrent.internal.LatestValueSubscriber
    This class is no longer used by ServiceTalk and will be removed in the future releases. If you depend on it, consider copying into your codebase.
    io.servicetalk.data.jackson.JacksonSerializationProvider
    Use JacksonSerializerFactory.
    io.servicetalk.data.protobuf.ProtobufSerializationProvider
    Use ProtobufSerializerFactory.
    io.servicetalk.dns.discovery.netty.DefaultDnsServiceDiscovererBuilder
    this class will be made package-private in the future, rely on the DnsServiceDiscovererBuilder instead.
    io.servicetalk.encoding.api.internal.ContentCodecToBufferDecoder
    Use BufferDecoder. This type will be removed along with ContentCodec.
    io.servicetalk.encoding.api.internal.ContentCodecToBufferEncoder
    Use BufferEncoder. This type will be removed along with ContentCodec.
    io.servicetalk.encoding.netty.ContentCodings
    Use NettyCompression and NettyBufferEncoders.
    io.servicetalk.encoding.netty.ZipContentCodecBuilder
    Use ZipCompressionBuilder.
    io.servicetalk.grpc.protobuf.ProtoBufSerializationProviderBuilder
    The gRPC framing is now built into grpc-netty. This class is no longer necessary and will be removed in a future release. ProtoBufSerializationProviderBuilder.registerMessageType(Class, Parser) is used to add one or more MessageLite message types. Resulting GrpcSerializationProvider from ProtoBufSerializationProviderBuilder.build() will only serialize and deserialize those message types.
    io.servicetalk.health.v1.Health.CheckMetadata
    This class will be removed in the future in favor of direct usage of GrpcClientMetadata. Deprecation of GrpcMetadata.path() renders this type unnecessary.
    io.servicetalk.health.v1.Health.WatchMetadata
    This class will be removed in the future in favor of direct usage of GrpcClientMetadata. Deprecation of GrpcMetadata.path() renders this type unnecessary.
    io.servicetalk.http.api.ContentCodingHttpRequesterFilter
    Use ContentEncodingHttpRequesterFilter.
    io.servicetalk.http.api.ContentCodingHttpServiceFilter
    Use ContentEncodingHttpServiceFilter.
    io.servicetalk.http.api.HttpSerializationProviders
    Use HttpSerializers.
    io.servicetalk.http.api.StrategyInfluencerChainBuilder
    Merge ExecutionStrategy directly instead.
    io.servicetalk.http.netty.DefaultHttpLoadBalancerFactory
    use DefaultHttpLoadBalancerFactory instead.
    io.servicetalk.loadbalancer.DelegatingRoundRobinLoadBalancerBuilder
    use DelegatingLoadBalancerBuilder instead.
    io.servicetalk.loadbalancer.RoundRobinLoadBalancerFactory
    use LoadBalancers to create LoadBalancerFactory instances. RoundRobinLoadBalancerBuilder.
    io.servicetalk.loadbalancer.RoundRobinLoadBalancerFactory.Builder
    rely on the LoadBalancers.builder(String) instead.
    io.servicetalk.loadbalancer.RoundRobinLoadBalancers
    use LoadBalancers instead.
    io.servicetalk.opentelemetry.http.OpenTelemetryHttpRequestFilter
    use OpenTelemetryHttpRequesterFilter instead.
    io.servicetalk.opentelemetry.http.OpenTelemetryHttpServerFilter
    use OpenTelemetryHttpServiceFilter instead.
    io.servicetalk.serialization.api.DefaultSerializer
    Use implementations of following types:
    • Serializer
    • StreamingSerializer
    • Deserializer
    • StreamingDeserializer
    io.servicetalk.serialization.api.TypeHolder
    General Type serialization is not supported by all serializers. Defer to your specific Serializer implementation. For example jackson offers TypeReference which can be used directly.
    io.servicetalk.transport.netty.internal.BufferHandler
    This API is going to be removed in future releases with no planned replacement. If it cannot be removed from your application, consider copying it into your codebase.
    io.servicetalk.transport.netty.internal.DelegatingFlushStrategy
    this class will be made package-private in the future releases. If you depend on this code, consider copying it into your codebase.
    io.servicetalk.transport.netty.internal.SplittingFlushStrategy
    This class will be removed in the future releases.
  • Deprecated Exceptions
    Exceptions
    Description
    io.servicetalk.client.api.partition.ClosedPartitionException
    We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
    io.servicetalk.client.api.partition.DuplicateAttributeException
    We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
    io.servicetalk.client.api.partition.UnknownPartitionException
    We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
    io.servicetalk.concurrent.internal.QueueFullAndRejectedSubscribeException
    This class is no longer used by ServiceTalk and will be removed in the future releases. If you depend on it, consider copying into your codebase.
    io.servicetalk.encoding.api.CodecDecodingException
    Use BufferEncodingException.
    io.servicetalk.encoding.api.CodecEncodingException
    Use BufferEncodingException.
    io.servicetalk.grpc.api.MessageEncodingException
    This exception type was thrown only by ProtoBufSerializationProviderBuilder that was deprecated and will be removed in future releases. Use SerializationException instead that can be thrown by a new implementation.
    io.servicetalk.http.netty.ProxyResponseException
    Use ProxyConnectResponseException instead
    io.servicetalk.serialization.api.SerializationException
    Use SerializationException.
  • Deprecated Fields
    Field
    Description
    io.servicetalk.grpc.api.DefaultGrpcClientMetadata.INSTANCE
    Use DefaultGrpcClientMetadata() to create a new instance instead. GrpcClientMetadata contains modifiable GrpcMetadata.requestContext() and GrpcMetadata.responseContext() now. Using this constant there will be no access to the actual context and both mentioned methods will throw UnsupportedOperationException.
    io.servicetalk.health.v1.Health.BlockingCheckRpc.PATH
    Use Health.BlockingCheckRpc.methodDescriptor().
    io.servicetalk.health.v1.Health.BlockingWatchRpc.PATH
    Use Health.BlockingWatchRpc.methodDescriptor().
    io.servicetalk.health.v1.Health.CheckMetadata.INSTANCE
    Use DefaultGrpcClientMetadata.
    io.servicetalk.health.v1.Health.CheckRpc.PATH
    Use Health.CheckRpc.methodDescriptor().
    io.servicetalk.health.v1.Health.WatchMetadata.INSTANCE
    Use DefaultGrpcClientMetadata.
    io.servicetalk.health.v1.Health.WatchRpc.PATH
    Use Health.WatchRpc.methodDescriptor().
    io.servicetalk.http.api.HttpContextKeys.HTTP_TARGET_ADDRESS_BEHIND_PROXY
    Use TransportObserverConnectionFactoryFilter to configure TransportObserver and then listen ConnectionObserver.onProxyConnect(Object) callback to distinguish between a regular connection and a connection to the secure HTTP proxy tunnel. For clear text HTTP proxies, consider installing a custom client filter that will populate HttpMetaData.context() with a similar key or reach out to the ServiceTalk developers to discuss ideas.
    io.servicetalk.http.netty.RetryingHttpRequesterFilter.BackOffPolicy.NO_RETRIES
    This will be removed in a future release of ST. Alternative offering here RetryingHttpRequesterFilter.BackOffPolicy.ofNoRetries().
    io.servicetalk.http.netty.RetryingHttpRequesterFilter.HttpResponseException.message
    Use Throwable.getMessage().
    io.servicetalk.http.netty.RetryingHttpRequesterFilter.HttpResponseException.metaData
    Use RetryingHttpRequesterFilter.HttpResponseException.metaData().
  • Deprecated Methods
    Method
    Description
    io.servicetalk.buffer.api.CharSequences.asciiStringIndexOf(CharSequence, char, int)
    Use CharSequences.indexOf(CharSequence, char, int).
    io.servicetalk.client.api.ConnectionFactory.newConnection(ResolvedAddress, TransportObserver)
    Use ConnectionFactory.newConnection(Object, ContextMap, TransportObserver).
    io.servicetalk.client.api.ConnectionFactoryFilter.append(ConnectionFactoryFilter<ResolvedAddress, C>)
    consider using higher level client builders to append filters.
    io.servicetalk.client.api.DelegatingConnectionFactory.newConnection(ResolvedAddress, TransportObserver)
    io.servicetalk.client.api.LoadBalancedAddress.newConnection()
    Implement and use LoadBalancedAddress.newConnection(ContextMap).
    io.servicetalk.client.api.LoadBalancer.selectConnection(Predicate<C>)
    Use LoadBalancer.selectConnection(Predicate, ContextMap).
    io.servicetalk.client.api.LoadBalancerFactory.newLoadBalancer(Publisher<? extends ServiceDiscovererEvent<ResolvedAddress>>, ConnectionFactory<ResolvedAddress, T>)
    Use LoadBalancerFactory.newLoadBalancer(Publisher, ConnectionFactory, String).
    io.servicetalk.client.api.LoadBalancerFactory.newLoadBalancer(String, Publisher<? extends Collection<? extends ServiceDiscovererEvent<ResolvedAddress>>>, ConnectionFactory<ResolvedAddress, T>)
    Use LoadBalancerFactory.newLoadBalancer(Publisher, ConnectionFactory, String).
    io.servicetalk.concurrent.api.AsyncContext.forEachEntry(BiPredicate<ContextMap.Key<?>, Object>)
    Use AsyncContext.forEach(BiPredicate)
    io.servicetalk.concurrent.api.AsyncContext.putAllFromMap(Map<ContextMap.Key<?>, Object>)
    Use AsyncContext.putAll(Map)
    io.servicetalk.concurrent.api.AsyncContext.removeAllEntries(Iterable<ContextMap.Key<?>>)
    Use AsyncContext.removeAll(Iterable)
    io.servicetalk.concurrent.api.Publisher.fromInputStream(InputStream)
    Use Publisher.fromInputStream(InputStream, ByteArrayMapper) with ByteArrayMapper.toByteArray().
    io.servicetalk.concurrent.api.Publisher.fromInputStream(InputStream, int)
    Use Publisher.fromInputStream(InputStream, ByteArrayMapper) with ByteArrayMapper.toByteArray(int).
    io.servicetalk.concurrent.api.Publisher.multicastToExactly(int)
    Use Publisher.multicast(int).
    io.servicetalk.concurrent.api.Publisher.multicastToExactly(int, int)
    Use Publisher.multicast(int, int).
    io.servicetalk.concurrent.api.Publisher.scanWith(Supplier<? extends ScanWithMapper<? super T, ? extends R>>)
    Use Publisher.scanWithMapper(Supplier).
    io.servicetalk.concurrent.api.Publisher.scanWithLifetime(Supplier<? extends ScanWithLifetimeMapper<? super T, ? extends R>>)
    Use Publisher.scanWithLifetimeMapper(Supplier).
    io.servicetalk.concurrent.api.Single.concat(Publisher<? extends T>, boolean)
    Use Single.concat(Publisher) or Single.concatDeferSubscribe(Publisher) instead.
    io.servicetalk.concurrent.internal.AutoClosableUtils.closeAndReThrowUnchecked(AutoCloseable)
    Use AutoClosableUtils.closeAndReThrow(AutoCloseable).
    io.servicetalk.data.jackson.jersey.ServiceTalkJacksonSerializerFeature.contextResolverFor(ObjectMapper)
    Use ServiceTalkJacksonSerializerFeature.newContextResolver(ObjectMapper).
    io.servicetalk.data.jackson.jersey.ServiceTalkJacksonSerializerFeature.contextResolverFor(JacksonSerializationProvider)
    Use ServiceTalkJacksonSerializerFeature.newContextResolver(JacksonSerializerFactory).
    io.servicetalk.dns.discovery.netty.DefaultDnsServiceDiscovererBuilder.minTTL(int)
    Use DefaultDnsServiceDiscovererBuilder.ttl(int, int).
    io.servicetalk.dns.discovery.netty.DnsServiceDiscovererObserver.onNewDiscovery(String)
    use DnsServiceDiscovererObserver.onNewDiscovery(String, String) instead. To avoid breaking changes, all current implementations must implement both methods. In the next version the default implementation will swap. Then users will be able to keep implementation only for the new method. In the release after, the deprecated method will be removed.
    io.servicetalk.encoding.api.Identity.identity()
    Use Identity.identityEncoder().
    io.servicetalk.encoding.api.internal.HeaderUtils.encodingFor(Collection<ContentCodec>, CharSequence)
    Use HeaderUtils.encodingForRaw(List, Function, CharSequence).
    io.servicetalk.encoding.api.internal.HeaderUtils.negotiateAcceptedEncoding(CharSequence, List<ContentCodec>)
    Use HeaderUtils.negotiateAcceptedEncodingRaw(CharSequence, List, Function).
    io.servicetalk.encoding.api.internal.HeaderUtils.negotiateAcceptedEncoding(List<ContentCodec>, List<ContentCodec>)
    Use HeaderUtils.negotiateAcceptedEncodingRaw(CharSequence, List, Function).
    io.servicetalk.grpc.api.DefaultGrpcClientMetadata.requestEncoding()
    io.servicetalk.grpc.api.GrpcClientCallFactory.newBlockingCall(GrpcSerializationProvider, Class<Req>, Class<Resp>)
    use GrpcClientCallFactory.newBlockingCall(MethodDescriptor, BufferDecoderGroup).
    io.servicetalk.grpc.api.GrpcClientCallFactory.newBlockingRequestStreamingCall(GrpcSerializationProvider, Class<Req>, Class<Resp>)
    Use GrpcClientCallFactory.newBlockingRequestStreamingCall(MethodDescriptor, BufferDecoderGroup).
    io.servicetalk.grpc.api.GrpcClientCallFactory.newBlockingResponseStreamingCall(GrpcSerializationProvider, Class<Req>, Class<Resp>)
    Use GrpcClientCallFactory.newBlockingResponseStreamingCall(MethodDescriptor, BufferDecoderGroup).
    io.servicetalk.grpc.api.GrpcClientCallFactory.newBlockingStreamingCall(GrpcSerializationProvider, Class<Req>, Class<Resp>)
    Use GrpcClientCallFactory.newBlockingStreamingCall(MethodDescriptor, BufferDecoderGroup).
    io.servicetalk.grpc.api.GrpcClientCallFactory.newCall(GrpcSerializationProvider, Class<Req>, Class<Resp>)
    Use GrpcClientCallFactory.newCall(MethodDescriptor, BufferDecoderGroup).
    io.servicetalk.grpc.api.GrpcClientCallFactory.newRequestStreamingCall(GrpcSerializationProvider, Class<Req>, Class<Resp>)
    Use GrpcClientCallFactory.newRequestStreamingCall(MethodDescriptor, BufferDecoderGroup).
    io.servicetalk.grpc.api.GrpcClientCallFactory.newResponseStreamingCall(GrpcSerializationProvider, Class<Req>, Class<Resp>)
    Use GrpcClientCallFactory.newResponseStreamingCall(MethodDescriptor, BufferDecoderGroup).
    io.servicetalk.grpc.api.GrpcClientCallFactory.newStreamingCall(GrpcSerializationProvider, Class<Req>, Class<Resp>)
    Use GrpcClientCallFactory.newStreamingCall(MethodDescriptor, BufferDecoderGroup).
    io.servicetalk.grpc.api.GrpcClientFactory.supportedMessageCodings()
    Use generated code methods targeting List of BufferEncoders and BufferDecoderGroup.
    io.servicetalk.grpc.api.GrpcClientFactory.supportedMessageCodings(List<ContentCodec>)
    Use generated code methods targeting List of BufferEncoders and BufferDecoderGroup.
    io.servicetalk.grpc.api.GrpcClientMetadata.requestEncoding()
    Use GrpcClientMetadata.requestCompressor().
    io.servicetalk.grpc.api.GrpcExecutionStrategies.offloadNever()
    Use GrpcExecutionStrategies.offloadNone() instead.
    io.servicetalk.grpc.api.GrpcMetadata.path()
    Use MethodDescriptor.httpPath().
    io.servicetalk.grpc.api.GrpcRoutes.addBlockingRequestStreamingRoute(String, GrpcExecutionStrategy, GrpcRoutes.BlockingRequestStreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)
    Use GrpcRoutes.addBlockingRequestStreamingRoute(GrpcExecutionStrategy, MethodDescriptor, BufferDecoderGroup, List, BlockingRequestStreamingRoute).
    io.servicetalk.grpc.api.GrpcRoutes.addBlockingRequestStreamingRoute(String, Class<?>, String, GrpcRoutes.BlockingRequestStreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)
    Use GrpcRoutes.addBlockingStreamingRoute(Class, MethodDescriptor, BufferDecoderGroup, List, BlockingStreamingRoute).
    io.servicetalk.grpc.api.GrpcRoutes.addBlockingResponseStreamingRoute(String, GrpcExecutionStrategy, GrpcRoutes.BlockingResponseStreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)
    Use GrpcRoutes.addBlockingResponseStreamingRoute(GrpcExecutionStrategy, MethodDescriptor, BufferDecoderGroup, List, BlockingResponseStreamingRoute).
    io.servicetalk.grpc.api.GrpcRoutes.addBlockingResponseStreamingRoute(String, Class<?>, String, GrpcRoutes.BlockingResponseStreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)
    Use GrpcRoutes.addBlockingResponseStreamingRoute(Class, MethodDescriptor, BufferDecoderGroup, List, BlockingResponseStreamingRoute).
    io.servicetalk.grpc.api.GrpcRoutes.addBlockingRoute(String, GrpcExecutionStrategy, GrpcRoutes.BlockingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)
    Use GrpcRoutes.addBlockingRoute(GrpcExecutionStrategy, MethodDescriptor, BufferDecoderGroup, List, BlockingRoute).
    io.servicetalk.grpc.api.GrpcRoutes.addBlockingRoute(String, Class<?>, String, GrpcRoutes.BlockingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)
    Use GrpcRoutes.addBlockingRoute(Class, MethodDescriptor, BufferDecoderGroup, List, BlockingRoute).
    io.servicetalk.grpc.api.GrpcRoutes.addBlockingStreamingRoute(String, GrpcExecutionStrategy, GrpcRoutes.BlockingStreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)
    Use GrpcRoutes.addBlockingStreamingRoute(GrpcExecutionStrategy, MethodDescriptor, BufferDecoderGroup, List, BlockingStreamingRoute).
    io.servicetalk.grpc.api.GrpcRoutes.addBlockingStreamingRoute(String, Class<?>, String, GrpcRoutes.BlockingStreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)
    Use GrpcRoutes.addBlockingStreamingRoute(Class, MethodDescriptor, BufferDecoderGroup, List, BlockingStreamingRoute).
    io.servicetalk.grpc.api.GrpcRoutes.addRequestStreamingRoute(String, GrpcExecutionStrategy, GrpcRoutes.RequestStreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)
    Use GrpcRoutes.addRequestStreamingRoute(GrpcExecutionStrategy, MethodDescriptor, BufferDecoderGroup, List, RequestStreamingRoute).
    io.servicetalk.grpc.api.GrpcRoutes.addRequestStreamingRoute(String, Class<?>, String, GrpcRoutes.RequestStreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)
    Use GrpcRoutes.addRequestStreamingRoute(Class, MethodDescriptor, BufferDecoderGroup, List, RequestStreamingRoute).
    io.servicetalk.grpc.api.GrpcRoutes.addResponseStreamingRoute(String, GrpcExecutionStrategy, GrpcRoutes.ResponseStreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)
    Use GrpcRoutes.addResponseStreamingRoute(GrpcExecutionStrategy, MethodDescriptor, BufferDecoderGroup, List, ResponseStreamingRoute).
    io.servicetalk.grpc.api.GrpcRoutes.addResponseStreamingRoute(String, Class<?>, String, GrpcRoutes.ResponseStreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)
    Use GrpcRoutes.addResponseStreamingRoute(Class, MethodDescriptor, BufferDecoderGroup, List, ResponseStreamingRoute).
    io.servicetalk.grpc.api.GrpcRoutes.addRoute(String, GrpcExecutionStrategy, GrpcRoutes.Route<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)
    Use GrpcRoutes.addRoute(GrpcExecutionStrategy, MethodDescriptor, BufferDecoderGroup, List, Route).
    io.servicetalk.grpc.api.GrpcRoutes.addRoute(String, Class<?>, String, GrpcRoutes.Route<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)
    Use GrpcRoutes.addRoute(Class, MethodDescriptor, BufferDecoderGroup, List, Route).
    io.servicetalk.grpc.api.GrpcRoutes.addStreamingRoute(String, GrpcExecutionStrategy, GrpcRoutes.StreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)
    Use GrpcRoutes.addStreamingRoute(GrpcExecutionStrategy, MethodDescriptor, BufferDecoderGroup, List, StreamingRoute)
    io.servicetalk.grpc.api.GrpcRoutes.addStreamingRoute(String, Class<?>, String, GrpcRoutes.StreamingRoute<Req, Resp>, Class<Req>, Class<Resp>, GrpcSerializationProvider)
    Use GrpcRoutes.addStreamingRoute(Class, MethodDescriptor, BufferDecoderGroup, List, StreamingRoute).
    io.servicetalk.grpc.api.GrpcRoutes.BlockingResponseStreamingRoute.handle(GrpcServiceContext, Req, GrpcPayloadWriter<Resp>)
    Use GrpcRoutes.BlockingResponseStreamingRoute.handle(GrpcServiceContext, Object, BlockingStreamingGrpcServerResponse). In the next release, this method will have a default implementation but the new overload won't. To avoid breaking API changes, make sure to implement both methods. The release after next will remove this method. This intermediate step is necessary to maintain FunctionalInterface contract that requires to have a single non-default method. Note: if you also use GrpcRoutes.BlockingResponseStreamingRoute.wrap(GrpcRoutes.BlockingResponseStreamingRoute, GracefulAutoCloseable) method, make sure to pass there an implementation of GrpcRoutes.BlockingResponseStreamingRoute that implements both overloads instead of a lambda. Otherwise, the default GrpcRoutes.BlockingResponseStreamingRoute.handle(GrpcServiceContext, Object, BlockingStreamingGrpcServerResponse) implementation will be used.
    io.servicetalk.grpc.api.GrpcRoutes.BlockingStreamingRoute.handle(GrpcServiceContext, BlockingIterable<Req>, GrpcPayloadWriter<Resp>)
    Use GrpcRoutes.BlockingStreamingRoute.handle(GrpcServiceContext, BlockingIterable, BlockingStreamingGrpcServerResponse). In the next release, this method will have a default implementation but the new overload won't. To avoid breaking API changes, make sure to implement both methods. The release after next will remove this method. This intermediate step is necessary to maintain FunctionalInterface contract that requires to have a single non-default method. Note: if you also use GrpcRoutes.BlockingStreamingRoute.wrap(GrpcRoutes.BlockingStreamingRoute, GracefulAutoCloseable) method, make sure to pass there an implementation of GrpcRoutes.BlockingStreamingRoute that implements both overloads instead of a lambda. Otherwise, the default GrpcRoutes.BlockingStreamingRoute.handle(GrpcServiceContext, BlockingIterable, BlockingStreamingGrpcServerResponse) implementation will be used.
    io.servicetalk.grpc.api.GrpcRoutes.newServiceFromRoutes(GrpcRoutes.AllGrpcRoutes)
    This method is not used starting from version 0.42.0 (see PR#1893), we plan to remove it in future releases. In case you have a use-case, let us know.
    io.servicetalk.grpc.api.GrpcRoutes.registerRoutes(Service)
    This method is not used starting from version 0.42.0 (see PR#1893), we plan to remove it in future releases. In case you have a use-case, let us know.
    io.servicetalk.grpc.api.GrpcServiceContext.supportedMessageCodings()
    Will be removed along with ContentCodec.
    io.servicetalk.grpc.api.GrpcStatus.asException()
    Use GrpcStatusException(GrpcStatus).
    io.servicetalk.grpc.api.GrpcStatus.asException(Supplier<Status>)
    Use GrpcStatusException.of(Status).
    io.servicetalk.grpc.api.GrpcStatus.cause()
    Use GrpcStatusException.fromThrowable(Throwable) to create a GrpcStatusException then Throwable.getCause().
    io.servicetalk.grpc.api.GrpcStatus.fromThrowable(Throwable)
    Use GrpcStatusException.fromThrowable(Throwable).
    io.servicetalk.grpc.api.GrpcStatus.fromThrowableNullable(Throwable)
    Use GrpcStatusException.fromThrowable(Throwable).
    io.servicetalk.health.v1.Health.BlockingHealthClient.check(Health.CheckMetadata, HealthCheckRequest)
    Use Health.BlockingHealthClient.check(GrpcClientMetadata,HealthCheckRequest).
    io.servicetalk.health.v1.Health.BlockingHealthClient.watch(Health.WatchMetadata, HealthCheckRequest)
    Use Health.BlockingHealthClient.watch(GrpcClientMetadata,HealthCheckRequest).
    io.servicetalk.health.v1.Health.BlockingWatchRpc.watch(GrpcServiceContext, HealthCheckRequest, GrpcPayloadWriter<HealthCheckResponse>)
    Use Health.BlockingWatchRpc.watch(GrpcServiceContext, HealthCheckRequest, BlockingStreamingGrpcServerResponse). In the next release, this method will have a default implementation but the new overload won't. To avoid breaking API changes, make sure to implement both methods. The release after next will remove this method. This intermediate step is necessary to maintain FunctionalInterface contract that requires to have a single non-default method.
    io.servicetalk.health.v1.Health.HealthClient.check(Health.CheckMetadata, HealthCheckRequest)
    Use Health.HealthClient.check(GrpcClientMetadata,HealthCheckRequest).
    io.servicetalk.health.v1.Health.HealthClient.watch(Health.WatchMetadata, HealthCheckRequest)
    Use Health.HealthClient.watch(GrpcClientMetadata,HealthCheckRequest).
    io.servicetalk.health.v1.Health.ServiceFactory.Builder.addService(Health.BlockingHealthService)
    Use Health.ServiceFactory.Builder.addBlockingService(io.servicetalk.health.v1.Health.BlockingHealthService).
    io.servicetalk.health.v1.Health.ServiceFactory.Builder.newServiceFromRoutes(GrpcRoutes.AllGrpcRoutes)
    io.servicetalk.health.v1.Health.ServiceFactory.Builder.registerRoutes(Health.HealthService)
    io.servicetalk.health.v1.HealthCheckResponse.ServingStatus.valueOf(int)
    io.servicetalk.http.api.BlockingStreamingHttpRequest.encoding(ContentCodec)
    io.servicetalk.http.api.BlockingStreamingHttpRequest.payloadBody(HttpDeserializer<T>)
    Use BlockingStreamingHttpRequest.payloadBody(HttpStreamingDeserializer).
    io.servicetalk.http.api.BlockingStreamingHttpRequest.payloadBody(Iterable<T>, HttpSerializer<T>)
    Use BlockingStreamingHttpRequest.payloadBody(Iterable, HttpStreamingSerializer).
    io.servicetalk.http.api.BlockingStreamingHttpRequest.transform(TrailersTransformer<T, Buffer>)
    Use BlockingStreamingHttpRequest.messageBody() and BlockingStreamingHttpRequest.messageBody(HttpMessageBodyIterable).
    io.servicetalk.http.api.BlockingStreamingHttpRequest.transformPayloadBody(Function<BlockingIterable<Buffer>, BlockingIterable<T>>, HttpSerializer<T>)
    Use BlockingStreamingHttpRequest.payloadBody(HttpStreamingDeserializer) and BlockingStreamingHttpRequest.payloadBody(Iterable, HttpStreamingSerializer).
    io.servicetalk.http.api.BlockingStreamingHttpRequest.transformPayloadBody(Function<BlockingIterable<T>, BlockingIterable<R>>, HttpDeserializer<T>, HttpSerializer<R>)
    Use BlockingStreamingHttpRequest.payloadBody(HttpStreamingDeserializer) and BlockingStreamingHttpRequest.payloadBody(Iterable, HttpStreamingSerializer).
    io.servicetalk.http.api.BlockingStreamingHttpRequest.transformPayloadBody(UnaryOperator<BlockingIterable<Buffer>>)
    Use BlockingStreamingHttpRequest.payloadBody() and BlockingStreamingHttpRequest.payloadBody(Iterable).
    io.servicetalk.http.api.BlockingStreamingHttpResponse.encoding(ContentCodec)
    io.servicetalk.http.api.BlockingStreamingHttpResponse.payloadBody(HttpDeserializer<T>)
    Use BlockingStreamingHttpResponse.payloadBody(HttpStreamingDeserializer).
    io.servicetalk.http.api.BlockingStreamingHttpResponse.payloadBody(Iterable<T>, HttpSerializer<T>)
    Use BlockingStreamingHttpResponse.payloadBody(Iterable, HttpStreamingSerializer).
    io.servicetalk.http.api.BlockingStreamingHttpResponse.transform(TrailersTransformer<T, Buffer>)
    Use BlockingStreamingHttpResponse.messageBody() and BlockingStreamingHttpResponse.messageBody(HttpMessageBodyIterable).
    io.servicetalk.http.api.BlockingStreamingHttpResponse.transformPayloadBody(Function<BlockingIterable<Buffer>, BlockingIterable<T>>, HttpSerializer<T>)
    Use BlockingStreamingHttpResponse.payloadBody(HttpStreamingDeserializer) and BlockingStreamingHttpResponse.payloadBody(Iterable, HttpStreamingSerializer).
    io.servicetalk.http.api.BlockingStreamingHttpResponse.transformPayloadBody(Function<BlockingIterable<T>, BlockingIterable<R>>, HttpDeserializer<T>, HttpSerializer<R>)
    Use BlockingStreamingHttpResponse.payloadBody(HttpStreamingDeserializer) and BlockingStreamingHttpResponse.payloadBody(Iterable, HttpStreamingSerializer).
    io.servicetalk.http.api.BlockingStreamingHttpResponse.transformPayloadBody(UnaryOperator<BlockingIterable<Buffer>>)
    Use BlockingStreamingHttpResponse.payloadBody() and BlockingStreamingHttpResponse.payloadBody(Iterable).
    io.servicetalk.http.api.BlockingStreamingHttpServerResponse.sendMetaData(HttpSerializer<T>)
    Use BlockingStreamingHttpServerResponse.sendMetaData(HttpStreamingSerializer).
    io.servicetalk.http.api.Http2SettingsBuilder.initialWindowSize(long)
    Use Http2SettingsBuilder.initialWindowSize(int).
    io.servicetalk.http.api.HttpApiConversions.toBlockingClient(StreamingHttpClient, HttpExecutionStrategyInfluencer)
    Use overload with HttpExecutionStrategy rather than HttpExecutionStrategyInfluencer
    io.servicetalk.http.api.HttpApiConversions.toBlockingConnection(StreamingHttpConnection, HttpExecutionStrategyInfluencer)
    Use overload with HttpExecutionStrategy rather than HttpExecutionStrategyInfluencer
    io.servicetalk.http.api.HttpApiConversions.toBlockingStreamingClient(StreamingHttpClient, HttpExecutionStrategyInfluencer)
    Use overload with HttpExecutionStrategy rather than HttpExecutionStrategyInfluencer
    io.servicetalk.http.api.HttpApiConversions.toBlockingStreamingConnection(StreamingHttpConnection, HttpExecutionStrategyInfluencer)
    Use overload with HttpExecutionStrategy rather than HttpExecutionStrategyInfluencer
    io.servicetalk.http.api.HttpApiConversions.toClient(StreamingHttpClient, HttpExecutionStrategyInfluencer)
    Use overload with HttpExecutionStrategy rather than HttpExecutionStrategyInfluencer
    io.servicetalk.http.api.HttpApiConversions.toConnection(StreamingHttpConnection, HttpExecutionStrategyInfluencer)
    Use overload with HttpExecutionStrategy rather than HttpExecutionStrategyInfluencer
    io.servicetalk.http.api.HttpApiConversions.toReservedBlockingConnection(ReservedStreamingHttpConnection, HttpExecutionStrategyInfluencer)
    Use overload with HttpExecutionStrategy rather than HttpExecutionStrategyInfluencer
    io.servicetalk.http.api.HttpApiConversions.toReservedBlockingStreamingConnection(ReservedStreamingHttpConnection, HttpExecutionStrategyInfluencer)
    Use overload with HttpExecutionStrategy rather than HttpExecutionStrategyInfluencer
    io.servicetalk.http.api.HttpApiConversions.toReservedConnection(ReservedStreamingHttpConnection, HttpExecutionStrategyInfluencer)
    Use overload with HttpExecutionStrategy rather than HttpExecutionStrategyInfluencer
    io.servicetalk.http.api.HttpApiConversions.toStreamingHttpService(BlockingHttpService, HttpExecutionStrategy)
    Use HttpApiConversions.toStreamingHttpService(HttpExecutionStrategy, BlockingHttpService) instead.
    io.servicetalk.http.api.HttpApiConversions.toStreamingHttpService(BlockingHttpService, HttpExecutionStrategyInfluencer)
    Use HttpApiConversions.toStreamingHttpService(HttpExecutionStrategy, BlockingHttpService) instead.
    io.servicetalk.http.api.HttpApiConversions.toStreamingHttpService(BlockingStreamingHttpService, HttpExecutionStrategy)
    use HttpApiConversions.toStreamingHttpService(HttpExecutionStrategy, BlockingStreamingHttpService) instead.
    io.servicetalk.http.api.HttpApiConversions.toStreamingHttpService(BlockingStreamingHttpService, HttpExecutionStrategyInfluencer)
    Use HttpApiConversions.toStreamingHttpService(HttpExecutionStrategy, BlockingStreamingHttpService) instead.
    io.servicetalk.http.api.HttpApiConversions.toStreamingHttpService(HttpService, HttpExecutionStrategy)
    use HttpApiConversions.toStreamingHttpService(HttpExecutionStrategy, HttpService) instead.
    io.servicetalk.http.api.HttpApiConversions.toStreamingHttpService(HttpService, HttpExecutionStrategyInfluencer)
    Use HttpApiConversions.toStreamingHttpService(HttpExecutionStrategy, HttpService) instead.
    io.servicetalk.http.api.HttpExecutionStrategies.offloadNever()
    Use HttpExecutionStrategies.offloadNone() instead.
    io.servicetalk.http.api.HttpExecutionStrategyInfluencer.defaultStreamingInfluencer()
    This method is not useful anymore and will be removed in future releases.
    io.servicetalk.http.api.HttpExecutionStrategyInfluencer.influenceStrategy(HttpExecutionStrategy)
    Implement HttpExecutionStrategyInfluencer.requiredOffloads() instead.
    io.servicetalk.http.api.HttpLoadBalancerFactory.toLoadBalancedConnection(FilterableStreamingHttpConnection)
    Implement and use HttpLoadBalancerFactory.toLoadBalancedConnection(FilterableStreamingHttpConnection, ReservableRequestConcurrencyController, ContextMap)
    io.servicetalk.http.api.HttpMetaData.encoding()
    Use HttpRequestMetaData.contentEncoding() for requests and ContentEncodingHttpServiceFilter for responses. An example can be found here.
    io.servicetalk.http.api.HttpMetaData.encoding(ContentCodec)
    Use HttpRequestMetaData.contentEncoding(BufferEncoder) for requests and ContentEncodingHttpServiceFilter for responses. An example can be found here.
    io.servicetalk.http.api.HttpProviders.MultiAddressHttpClientBuilderProvider.newBuilder(MultiAddressHttpClientBuilder<U, R>)
    Use HttpProviders.MultiAddressHttpClientBuilderProvider.newBuilder(String, MultiAddressHttpClientBuilder). To avoid breaking changes, all current implementations must implement both methods. In the next version the default implementation will swap. Then users will be able to keep implementation only for the new method. In the release after, the deprecated method will be removed.
    io.servicetalk.http.api.HttpRequest.encoding(ContentCodec)
    io.servicetalk.http.api.HttpRequest.payloadBody(HttpDeserializer<T>)
    Use HttpRequest.payloadBody(HttpDeserializer2).
    io.servicetalk.http.api.HttpRequest.payloadBody(T, HttpSerializer<T>)
    Use HttpRequest.payloadBody(Object, HttpSerializer2).
    io.servicetalk.http.api.HttpResponse.payloadBody(HttpDeserializer<T>)
    Use HttpResponse.payloadBody(HttpDeserializer2).
    io.servicetalk.http.api.HttpResponse.payloadBody(T, HttpSerializer<T>)
    Use HttpResponse.payloadBody(Object, HttpSerializer2).
    io.servicetalk.http.api.HttpSerializationProviders.formUrlEncodedDeserializer()
    Use HttpSerializers.formUrlEncodedSerializer().
    io.servicetalk.http.api.HttpSerializationProviders.formUrlEncodedDeserializer(Charset)
    Use HttpSerializers.formUrlEncodedSerializer(Charset).
    io.servicetalk.http.api.HttpSerializationProviders.formUrlEncodedDeserializer(Charset, Predicate<HttpHeaders>)
    Use HttpSerializers.formUrlEncodedSerializer(Charset).
    io.servicetalk.http.api.HttpSerializationProviders.formUrlEncodedSerializer()
    Use HttpSerializers.formUrlEncodedSerializer().
    io.servicetalk.http.api.HttpSerializationProviders.formUrlEncodedSerializer(Charset)
    Use HttpSerializers.formUrlEncodedSerializer(Charset).
    io.servicetalk.http.api.HttpSerializationProviders.formUrlEncodedSerializer(Charset, Consumer<HttpHeaders>)
    Use HttpSerializers.formUrlEncodedSerializer(Charset).
    io.servicetalk.http.api.HttpSerializationProviders.jsonSerializer(SerializationProvider)
    Use HttpSerializers.jsonSerializer(SerializerDeserializer) or HttpSerializers.jsonStreamingSerializer(StreamingSerializerDeserializer).
    io.servicetalk.http.api.HttpSerializationProviders.jsonSerializer(Serializer)
    Use HttpSerializers.jsonSerializer(SerializerDeserializer) or HttpSerializers.jsonStreamingSerializer(StreamingSerializerDeserializer).
    io.servicetalk.http.api.HttpSerializationProviders.serializationProvider(SerializationProvider, Consumer<HttpHeaders>, Predicate<HttpHeaders>)
    Use HttpSerializers, HttpSerializer2, HttpDeserializer2, HttpStreamingSerializer, and HttpStreamingDeserializer.
    io.servicetalk.http.api.HttpSerializationProviders.serializationProvider(Serializer, Consumer<HttpHeaders>, Predicate<HttpHeaders>)
    Use HttpSerializers, HttpSerializer2, HttpDeserializer2, HttpStreamingSerializer, and HttpStreamingDeserializer.
    io.servicetalk.http.api.HttpSerializationProviders.textDeserializer()
    Use HttpSerializers.textSerializerUtf8() for aggregated. For streaming, use one of the following:
    • HttpSerializers.appSerializerUtf8FixLen()
    • HttpSerializers.appSerializerAsciiVarLen()
    • Aggregate the payload (e.g. StreamingHttpRequest.toRequest()) and use HttpSerializers.textSerializer(Charset) if your payload is text
    • HttpSerializers.streamingSerializer(StreamingSerializerDeserializer, Consumer, Predicate) targeted at your HttpHeaderNames.CONTENT_TYPE
    io.servicetalk.http.api.HttpSerializationProviders.textDeserializer(Charset)
    Use HttpSerializers.textSerializer(Charset) for aggregated. For streaming, use one of the following:
    • HttpSerializers.appSerializerUtf8FixLen()
    • HttpSerializers.appSerializerAsciiVarLen()
    • Aggregate the payload (e.g. StreamingHttpRequest.toRequest()) and use HttpSerializers.textSerializer(Charset) if your payload is text
    • HttpSerializers.streamingSerializer(StreamingSerializerDeserializer, Consumer, Predicate) targeted at your HttpHeaderNames.CONTENT_TYPE
    io.servicetalk.http.api.HttpSerializationProviders.textDeserializer(Charset, Predicate<HttpHeaders>)
    Use HttpSerializers.textSerializer(Charset) for aggregated. For streaming, use one of the following:
    • HttpSerializers.appSerializerUtf8FixLen()
    • HttpSerializers.appSerializerAsciiVarLen()
    • Aggregate the payload (e.g. StreamingHttpRequest.toRequest()) and use HttpSerializers.textSerializer(Charset) if your payload is text
    • HttpSerializers.streamingSerializer(StreamingSerializerDeserializer, Consumer, Predicate) targeted at your HttpHeaderNames.CONTENT_TYPE
    io.servicetalk.http.api.HttpSerializationProviders.textSerializer()
    Use HttpSerializers.textSerializerUtf8() for aggregated. For streaming, use one of the following:
    • HttpSerializers.appSerializerUtf8FixLen()
    • HttpSerializers.appSerializerAsciiVarLen()
    • HttpSerializers.stringStreamingSerializer(Charset, Consumer)
    io.servicetalk.http.api.HttpSerializationProviders.textSerializer(Charset)
    Use HttpSerializers.textSerializer(Charset) for aggregated. For streaming, use one of the following:
    • HttpSerializers.appSerializerUtf8FixLen()
    • HttpSerializers.appSerializerAsciiVarLen()
    • HttpSerializers.stringStreamingSerializer(Charset, Consumer)
    io.servicetalk.http.api.HttpSerializationProviders.textSerializer(Charset, Consumer<HttpHeaders>)
    Use HttpSerializers.textSerializer(Charset) for aggregated. For streaming, use one of the following:
    • HttpSerializers.appSerializerUtf8FixLen()
    • HttpSerializers.appSerializerAsciiVarLen()
    • HttpSerializers.stringStreamingSerializer(Charset, Consumer)
    io.servicetalk.http.api.HttpServerBuilder.appendConnectionAcceptorFilter(ConnectionAcceptorFactory)
    use HttpServerBuilder.appendLateConnectionAcceptor(LateConnectionAcceptor) instead.
    io.servicetalk.http.api.SingleAddressHttpClientBuilder.proxyAddress(U)
    Use SingleAddressHttpClientBuilder.proxyConfig(ProxyConfig) with ProxyConfig.forAddress(Object).
    io.servicetalk.http.api.StreamingHttpRequest.encoding(ContentCodec)
    io.servicetalk.http.api.StreamingHttpRequest.payloadBody(Publisher<T>, HttpSerializer<T>)
    Use StreamingHttpRequest.payloadBody(Publisher, HttpStreamingSerializer).
    io.servicetalk.http.api.StreamingHttpRequest.payloadBody(HttpDeserializer<T>)
    Use StreamingHttpRequest.payloadBody(HttpStreamingDeserializer).
    io.servicetalk.http.api.StreamingHttpRequest.transformPayloadBody(Function<Publisher<Buffer>, Publisher<T>>, HttpSerializer<T>)
    Use StreamingHttpRequest.transformPayloadBody(Function, HttpStreamingSerializer).
    io.servicetalk.http.api.StreamingHttpRequest.transformPayloadBody(Function<Publisher<T>, Publisher<R>>, HttpDeserializer<T>, HttpSerializer<R>)
    Use StreamingHttpRequest.transformPayloadBody(Function, HttpStreamingDeserializer, HttpStreamingSerializer).
    io.servicetalk.http.api.StreamingHttpResponse.encoding(ContentCodec)
    io.servicetalk.http.api.StreamingHttpResponse.payloadBody(Publisher<T>, HttpSerializer<T>)
    Use StreamingHttpResponse.payloadBody(Publisher, HttpStreamingSerializer).
    io.servicetalk.http.api.StreamingHttpResponse.payloadBody(HttpDeserializer<T>)
    Use StreamingHttpResponse.payloadBody(HttpStreamingDeserializer).
    io.servicetalk.http.api.StreamingHttpResponse.transformPayloadBody(Function<Publisher<Buffer>, Publisher<T>>, HttpSerializer<T>)
    Use StreamingHttpResponse.transformPayloadBody(Function, HttpStreamingSerializer).
    io.servicetalk.http.api.StreamingHttpResponse.transformPayloadBody(Function<Publisher<T>, Publisher<R>>, HttpDeserializer<T>, HttpSerializer<R>)
    Use StreamingHttpResponse.transformPayloadBody(Function, HttpStreamingDeserializer, HttpStreamingSerializer).
    io.servicetalk.http.netty.DefaultHttpLoadBalancerFactory.Builder.fromDefaults()
    use DefaultHttpLoadBalancerFactory and wrap the raw load balancer factory you're interested in using.
    io.servicetalk.http.netty.HttpClients.forMultiAddressUrl(ServiceDiscoverer<HostAndPort, InetSocketAddress, ServiceDiscovererEvent<InetSocketAddress>>)
    Use HttpClients.forMultiAddressUrl() to create MultiAddressHttpClientBuilder, then use MultiAddressHttpClientBuilder.initializer(SingleAddressInitializer) to override ServiceDiscoverer using SingleAddressHttpClientBuilder.serviceDiscoverer(ServiceDiscoverer) for all or some of the internal clients.
    io.servicetalk.http.netty.HttpClients.forPartitionedAddress(ServiceDiscoverer<U, R, PartitionedServiceDiscovererEvent<R>>, U, Function<HttpRequestMetaData, PartitionAttributesBuilder>)
    We are unaware of anyone using "partition" feature and plan to remove it in future releases. If you depend on it, consider using ClientGroup as an alternative or reach out to the maintainers describing the use-case.
    io.servicetalk.http.netty.RetryingHttpRequesterFilter.BackOffPolicy.ofImmediate()
    Use RetryingHttpRequesterFilter.BackOffPolicy.ofImmediateBounded().
    io.servicetalk.http.netty.RetryingHttpRequesterFilter.Builder.retryDelayedRetries(BiFunction<HttpRequestMetaData, RetryingHttpRequesterFilter.DelayedRetry, RetryingHttpRequesterFilter.BackOffPolicy>)
    Use RetryingHttpRequesterFilter.Builder.retryDelayedRetryExceptions(BiFunction) instead.
    io.servicetalk.http.utils.TimeoutFromRequest.toTimeoutFromRequest(Function<HttpRequestMetaData, Duration>, HttpExecutionStrategy)
    In areas which require TimeoutFromRequest use variants that accept BiFunction<HttpRequestMetaData, TimeSource, Duration>. E.g.: TimeoutHttpRequesterFilter(BiFunction, boolean), TimeoutHttpServiceFilter(BiFunction, boolean) for filters. Note that passed BiFunction should never block.
    io.servicetalk.loadbalancer.RoundRobinLoadBalancerFactory.Builder.healthCheckInterval(Duration)
    Use RoundRobinLoadBalancerFactory.Builder.healthCheckInterval(Duration, Duration).
    io.servicetalk.loadbalancer.RoundRobinLoadBalancerFactory.newLoadBalancer(String, Publisher<? extends Collection<? extends ServiceDiscovererEvent<ResolvedAddress>>>, ConnectionFactory<ResolvedAddress, T>)
    io.servicetalk.loadbalancer.RoundRobinLoadBalancers.builder(String)
    use {#LoadBalancers} constructors instead.
    io.servicetalk.serialization.api.Serializer.deserialize(Publisher<Buffer>, TypeHolder<T>)
    Use StreamingDeserializer.deserialize(Publisher, BufferAllocator).
    io.servicetalk.serialization.api.Serializer.deserialize(Publisher<Buffer>, Class<T>)
    Use StreamingDeserializer.deserialize(Publisher, BufferAllocator).
    io.servicetalk.serialization.api.Serializer.deserialize(BlockingIterable<Buffer>, TypeHolder<T>)
    Use StreamingDeserializer.deserialize(Iterable, BufferAllocator).
    io.servicetalk.serialization.api.Serializer.deserialize(BlockingIterable<Buffer>, Class<T>)
    Use StreamingDeserializer.deserialize(Iterable, BufferAllocator).
    io.servicetalk.serialization.api.Serializer.deserialize(Iterable<Buffer>, TypeHolder<T>)
    Use StreamingDeserializer.deserialize(Iterable, BufferAllocator).
    io.servicetalk.serialization.api.Serializer.deserialize(Iterable<Buffer>, Class<T>)
    Use StreamingDeserializer.deserialize(Iterable, BufferAllocator).
    io.servicetalk.serialization.api.Serializer.deserializeAggregated(Buffer, TypeHolder<T>)
    Use StreamingDeserializer that understands your protocol's framing.
    io.servicetalk.serialization.api.Serializer.deserializeAggregated(Buffer, Class<T>)
    Use StreamingDeserializer that understands your protocol's framing.
    io.servicetalk.serialization.api.Serializer.deserializeAggregatedSingle(Buffer, TypeHolder<T>)
    Use Deserializer.
    io.servicetalk.serialization.api.Serializer.deserializeAggregatedSingle(Buffer, Class<T>)
    Use Deserializer.
    io.servicetalk.serialization.api.Serializer.serialize(Publisher<T>, BufferAllocator, TypeHolder<T>)
    Use StreamingSerializer.serialize(Publisher, BufferAllocator).
    io.servicetalk.serialization.api.Serializer.serialize(Publisher<T>, BufferAllocator, TypeHolder<T>, IntUnaryOperator)
    Use StreamingSerializer.serialize(Publisher, BufferAllocator).
    io.servicetalk.serialization.api.Serializer.serialize(Publisher<T>, BufferAllocator, Class<T>)
    Use StreamingSerializer.serialize(Publisher, BufferAllocator).
    io.servicetalk.serialization.api.Serializer.serialize(Publisher<T>, BufferAllocator, Class<T>, IntUnaryOperator)
    Use StreamingSerializer.serialize(Publisher, BufferAllocator).
    io.servicetalk.serialization.api.Serializer.serialize(BlockingIterable<T>, BufferAllocator, TypeHolder<T>)
    Use StreamingSerializer.serialize(Iterable, BufferAllocator).
    io.servicetalk.serialization.api.Serializer.serialize(BlockingIterable<T>, BufferAllocator, TypeHolder<T>, IntUnaryOperator)
    Use StreamingSerializer.serialize(Iterable, BufferAllocator).
    io.servicetalk.serialization.api.Serializer.serialize(BlockingIterable<T>, BufferAllocator, Class<T>)
    Use StreamingSerializer.serialize(Iterable, BufferAllocator).
    io.servicetalk.serialization.api.Serializer.serialize(BlockingIterable<T>, BufferAllocator, Class<T>, IntUnaryOperator)
    Use StreamingSerializer.serialize(Iterable, BufferAllocator).
    io.servicetalk.serialization.api.Serializer.serialize(Iterable<T>, BufferAllocator, TypeHolder<T>)
    Use StreamingSerializer.serialize(Iterable, BufferAllocator).
    io.servicetalk.serialization.api.Serializer.serialize(Iterable<T>, BufferAllocator, TypeHolder<T>, IntUnaryOperator)
    Use StreamingSerializer.serialize(Iterable, BufferAllocator).
    io.servicetalk.serialization.api.Serializer.serialize(Iterable<T>, BufferAllocator, Class<T>)
    Use StreamingSerializer.serialize(Iterable, BufferAllocator).
    io.servicetalk.serialization.api.Serializer.serialize(Iterable<T>, BufferAllocator, Class<T>, IntUnaryOperator)
    Use StreamingSerializer.serialize(Iterable, BufferAllocator).
    io.servicetalk.serialization.api.Serializer.serialize(T, Buffer)
    Use Serializer
    io.servicetalk.serialization.api.Serializer.serialize(T, BufferAllocator)
    Use Serializer.serialize(Object, BufferAllocator).
    io.servicetalk.serialization.api.Serializer.serialize(T, BufferAllocator, int)
    Use Serializer.serialize(Object, BufferAllocator).
    io.servicetalk.serialization.api.StreamingDeserializer.deserialize(Buffer)
    Use StreamingDeserializer that understands your protocol's framing.
    io.servicetalk.serialization.api.StreamingDeserializer.deserialize(BlockingIterable<Buffer>)
    Use StreamingDeserializer.deserialize(Iterable, BufferAllocator).
    io.servicetalk.serialization.api.StreamingDeserializer.deserialize(Iterable<Buffer>)
    Use StreamingDeserializer.deserialize(Iterable, BufferAllocator).
    io.servicetalk.serialization.api.StreamingSerializer.serialize(Object, Buffer)
    Use StreamingSerializer.
    io.servicetalk.tcp.netty.internal.TcpServerBinder.bind(SocketAddress, ReadOnlyTcpServerConfig, boolean, ExecutionContext<?>, InfluencerConnectionAcceptor, BiFunction<Channel, ConnectionObserver, Single<CC>>, Consumer<CC>)
    use the bind method with early and late acceptors instead.
    io.servicetalk.transport.api.ConnectionObserver.onSecurityHandshake()
    use ConnectionObserver.onSecurityHandshake(SslConfig)
    io.servicetalk.transport.api.ConnectionObserver.onTransportHandshakeComplete()
    Use ConnectionObserver.onTransportHandshakeComplete(ConnectionInfo)
    io.servicetalk.transport.api.ConnectionObserver.ReadObserver.itemRead()
    Use ConnectionObserver.ReadObserver.itemRead(Object)
    io.servicetalk.transport.api.ConnectionObserver.WriteObserver.itemReceived()
    Use {ConnectionObserver.WriteObserver.itemReceived(Object)}
    io.servicetalk.transport.api.ConnectionObserver.WriteObserver.itemWritten()
    Use ConnectionObserver.WriteObserver.itemWritten(Object)
    io.servicetalk.transport.api.EarlyConnectionAcceptor.accept(ConnectionInfo)
    Implement EarlyConnectionAcceptor.accept(ConnectionContext) instead
    io.servicetalk.transport.api.LateConnectionAcceptor.accept(ConnectionInfo)
    Implement LateConnectionAcceptor.accept(ConnectionContext) instead
    io.servicetalk.transport.api.TransportObserver.onNewConnection()
    Use TransportObserver.onNewConnection(Object, Object)
    io.servicetalk.transport.netty.internal.DefaultNettyConnection.initChannel(Channel, BufferAllocator, Executor, IoExecutor, CloseHandler, FlushStrategy, long, SslConfig, ChannelInitializer, ExecutionStrategy, ConnectionInfo.Protocol, ConnectionObserver, boolean, Predicate<Object>)
    Use #initChannel(Channel, ExecutionContext, CloseHandler, FlushStrategy, long, SslConfig, ChannelInitializer, Protocol, ConnectionObserver, boolean, Predicate).
    io.servicetalk.transport.netty.internal.DefaultNettyConnection.initChannel(Channel, BufferAllocator, Executor, IoExecutor, CloseHandler, FlushStrategy, Long, ChannelInitializer, ExecutionStrategy, ConnectionInfo.Protocol, ConnectionObserver, boolean)
    Use #initChannel(Channel, ExecutionContext, CloseHandler, FlushStrategy, long, SslConfig, ChannelInitializer, Protocol, ConnectionObserver, boolean, Predicate).
    io.servicetalk.transport.netty.internal.DefaultNettyConnection.initChannel(Channel, BufferAllocator, Executor, IoExecutor, CloseHandler, FlushStrategy, Long, ChannelInitializer, ExecutionStrategy, ConnectionInfo.Protocol, ConnectionObserver, boolean, Predicate<Object>)
    Use #initChannel(Channel, ExecutionContext, CloseHandler, FlushStrategy, long, SslConfig, ChannelInitializer, Protocol, ConnectionObserver, boolean, Predicate).
    io.servicetalk.transport.netty.internal.DefaultNettyConnection.initChildChannel(Channel, ExecutionContext<?>, CloseHandler, FlushStrategy, long, ConnectionInfo.Protocol, SslConfig, SSLSession, ChannelConfig, ConnectionObserver.StreamObserver, boolean, Predicate<Object>, UnaryOperator<Throwable>)
    Use #initChildChannel(Channel, ConnectionContext, CloseHandler, FlushStrategy, long, Protocol, ChannelConfig, StreamObserver, boolean, Predicate, UnaryOperator).
    io.servicetalk.transport.netty.internal.DefaultNettyConnection.initChildChannel(Channel, ExecutionContext<?>, CloseHandler, FlushStrategy, Long, ConnectionInfo.Protocol, SSLSession, ChannelConfig, ConnectionObserver.StreamObserver, boolean, Predicate<Object>, UnaryOperator<Throwable>)
    Use #initChildChannel(Channel, ConnectionContext, CloseHandler, FlushStrategy, long, Protocol, ChannelConfig, StreamObserver, boolean, Predicate, UnaryOperator).
    io.servicetalk.transport.netty.internal.DefaultNettyConnection.initChildChannel(Channel, ExecutionContext<?>, CloseHandler, FlushStrategy, Long, ConnectionInfo.Protocol, SSLSession, ChannelConfig, ConnectionObserver.StreamObserver, boolean, UnaryOperator<Throwable>)
    Use #initChildChannel(Channel, ConnectionContext, CloseHandler, FlushStrategy, long, Protocol, ChannelConfig, StreamObserver, boolean, Predicate, UnaryOperator).
    io.servicetalk.transport.netty.internal.NettyIoExecutor.asExecutor()
    IoExecutor now implements Executor so this method is redundant.
    io.servicetalk.transport.netty.internal.NettyIoExecutors.fromNettyEventLoop(EventLoop)
    Use NettyIoExecutors.fromNettyEventLoop(EventLoop, boolean).
    io.servicetalk.transport.netty.internal.NettyIoExecutors.fromNettyEventLoopGroup(EventLoopGroup)
    Use NettyIoExecutors.fromNettyEventLoopGroup(EventLoopGroup, boolean).
    io.servicetalk.transport.netty.internal.NettyIoExecutors.toNettyIoExecutor(IoExecutor)
    Use EventLoopAwareNettyIoExecutors.toEventLoopAwareNettyIoExecutor(IoExecutor).
    io.servicetalk.transport.netty.internal.NettyPipelineSslUtils.extractSslSessionAndReport(ChannelPipeline, SslHandshakeCompletionEvent, Consumer<Throwable>, boolean)
    Use NettyPipelineSslUtils.extractSslSession(ChannelPipeline, SslHandshakeCompletionEvent, Consumer) instead, reporting to ConnectionObserver.SecurityHandshakeObserver is handled automatically for all SslHandlers initialized by SslClientChannelInitializer or SslServerChannelInitializer.
    io.servicetalk.transport.netty.internal.NettyPipelineSslUtils.extractSslSessionAndReport(SslConfig, ChannelPipeline, ConnectionObserver)
    Use NettyPipelineSslUtils.extractSslSession(SslConfig, ChannelPipeline) instead, reporting to ConnectionObserver.SecurityHandshakeObserver is handled automatically for all SslHandlers initialized by SslClientChannelInitializer or SslServerChannelInitializer
    io.servicetalk.transport.netty.internal.NettyPipelineSslUtils.isSslEnabled(ChannelPipeline)
    not required anymore, will be removed in the future releases, see NettyPipelineSslUtils.extractSslSessionAndReport(SslConfig, ChannelPipeline, ConnectionObserver) for an alternative approach
    io.servicetalk.utils.internal.PlatformDependent.hasUnsafe()
    This method is not used by internal ServiceTalk code anymore and will be removed in future releases.
    io.servicetalk.utils.internal.PlatformDependent.throwException(Throwable)
    Use ThrowableUtils.throwException(Throwable).
  • Deprecated Constructors
    Constructor
    Description
    io.servicetalk.dns.discovery.netty.DefaultDnsServiceDiscovererBuilder()
    use DnsServiceDiscoverers.builder(String) instead.
    io.servicetalk.grpc.api.DefaultGrpcClientMetadata(String)
    Use DefaultGrpcClientMetadata().
    io.servicetalk.grpc.api.DefaultGrpcClientMetadata(String, ContentCodec)
    Use DefaultGrpcClientMetadata(BufferEncoder)
    io.servicetalk.grpc.api.DefaultGrpcClientMetadata(String, ContentCodec, Duration)
    Use DefaultGrpcClientMetadata(BufferEncoder, Duration).
    io.servicetalk.grpc.api.DefaultGrpcClientMetadata(String, GrpcClientMetadata)
    Use DefaultGrpcClientMetadata(DefaultGrpcClientMetadata).
    io.servicetalk.grpc.api.DefaultGrpcClientMetadata(String, GrpcExecutionStrategy)
    Use DefaultGrpcClientMetadata(GrpcExecutionStrategy, BufferEncoder).
    io.servicetalk.grpc.api.DefaultGrpcClientMetadata(String, GrpcExecutionStrategy, ContentCodec)
    Use DefaultGrpcClientMetadata(GrpcExecutionStrategy, BufferEncoder).
    io.servicetalk.grpc.api.DefaultGrpcClientMetadata(String, GrpcExecutionStrategy, ContentCodec, Duration)
    Use DefaultGrpcClientMetadata(GrpcExecutionStrategy, BufferEncoder, Duration).
    io.servicetalk.grpc.api.DefaultGrpcClientMetadata(String, GrpcExecutionStrategy, Duration)
    Use DefaultGrpcClientMetadata(GrpcExecutionStrategy, BufferEncoder, Duration).
    io.servicetalk.grpc.api.DefaultGrpcClientMetadata(String, Duration)
    Use DefaultGrpcClientMetadata(BufferEncoder, Duration).
    io.servicetalk.grpc.api.DefaultGrpcClientMetadata(String, Supplier<ContextMap>, Supplier<ContextMap>, GrpcExecutionStrategy, ContentCodec, Duration)
    io.servicetalk.grpc.api.GrpcRoutes(RouteExecutionStrategyFactory<GrpcExecutionStrategy>)
    this constructor is not needed anymore, use GrpcRoutes() instead.
    io.servicetalk.grpc.api.GrpcStatus(GrpcStatusCode, Throwable)
    Use GrpcStatusException if there is a Throwable cause.
    io.servicetalk.grpc.api.GrpcStatus(GrpcStatusCode, Throwable, CharSequence)
    Use GrpcStatusException if there is a cause or GrpcStatus(GrpcStatusCode, String).
    io.servicetalk.health.v1.Health.ServiceFactory(Health.BlockingHealthService, RouteExecutionStrategyFactory<GrpcExecutionStrategy>)
    Use Builder() and set the custom strategy on Health.ServiceFactory.Builder.routeExecutionStrategyFactory(RouteExecutionStrategyFactory) instead.
    io.servicetalk.health.v1.Health.ServiceFactory(Health.BlockingHealthService, RouteExecutionStrategyFactory<GrpcExecutionStrategy>, List<ContentCodec>)
    Use Builder(RouteExecutionStrategyFactory), Health.ServiceFactory.Builder.bufferDecoderGroup(BufferDecoderGroup), and Health.ServiceFactory.Builder.bufferEncoders(List).
    io.servicetalk.health.v1.Health.ServiceFactory(Health.BlockingHealthService, List<ContentCodec>)
    Use Builder(), Health.ServiceFactory.Builder.bufferDecoderGroup(BufferDecoderGroup), and Health.ServiceFactory.Builder.bufferEncoders(List).
    io.servicetalk.health.v1.Health.ServiceFactory(Health.HealthService, RouteExecutionStrategyFactory<GrpcExecutionStrategy>)
    Use Builder() and set the custom strategy on Health.ServiceFactory.Builder.routeExecutionStrategyFactory(RouteExecutionStrategyFactory) instead.
    io.servicetalk.health.v1.Health.ServiceFactory(Health.HealthService, RouteExecutionStrategyFactory<GrpcExecutionStrategy>, List<ContentCodec>)
    Use Builder(RouteExecutionStrategyFactory), Health.ServiceFactory.Builder.bufferDecoderGroup(BufferDecoderGroup), and Health.ServiceFactory.Builder.bufferEncoders(List).
    io.servicetalk.health.v1.Health.ServiceFactory(Health.HealthService, List<ContentCodec>)
    Use Builder(), Health.ServiceFactory.Builder.bufferDecoderGroup(BufferDecoderGroup), and Health.ServiceFactory.Builder.bufferEncoders(List).
    io.servicetalk.health.v1.Health.ServiceFactory.Builder(RouteExecutionStrategyFactory<GrpcExecutionStrategy>)
    use Health.ServiceFactory.Builder.routeExecutionStrategyFactory(RouteExecutionStrategyFactory) on the Builder instead.
    io.servicetalk.health.v1.Health.ServiceFactory.Builder(RouteExecutionStrategyFactory<GrpcExecutionStrategy>, List<ContentCodec>)
    Use Builder(RouteExecutionStrategyFactory), Health.ServiceFactory.Builder.bufferDecoderGroup(BufferDecoderGroup), and Health.ServiceFactory.Builder.bufferEncoders(List).
    io.servicetalk.health.v1.Health.ServiceFactory.Builder(List<ContentCodec>)
    Use Health.ServiceFactory.Builder.bufferDecoderGroup(BufferDecoderGroup) and Health.ServiceFactory.Builder.bufferEncoders(List).
    io.servicetalk.http.utils.TimeoutHttpRequesterFilter(TimeoutFromRequest, boolean)
    Use TimeoutHttpRequesterFilter(BiFunction, boolean).
    io.servicetalk.http.utils.TimeoutHttpRequesterFilter(TimeoutFromRequest, boolean, Executor)
    Use TimeoutHttpRequesterFilter(BiFunction, boolean, Executor).
    io.servicetalk.http.utils.TimeoutHttpServiceFilter(TimeoutFromRequest, boolean)
    Use TimeoutHttpServiceFilter(BiFunction, boolean).
    io.servicetalk.http.utils.TimeoutHttpServiceFilter(TimeoutFromRequest, boolean, Executor)
    Use TimeoutHttpServiceFilter(BiFunction, boolean, Executor).
    io.servicetalk.loadbalancer.RoundRobinLoadBalancerFactory.Builder()
    use LoadBalancers.builder(String) instead.
    io.servicetalk.opentelemetry.http.OpenTelemetryHttpRequestFilter(OpenTelemetry, String)
    this method is internal, no user should be setting the OpenTelemetry as it is obtained by using GlobalOpenTelemetry.get() and there should be no other implementations but the one available in the classpath, this constructor will be removed in the future releases. Use OpenTelemetryHttpRequestFilter(String, OpenTelemetryOptions) or OpenTelemetryHttpRequestFilter() instead.
    io.servicetalk.opentelemetry.http.OpenTelemetryHttpServerFilter(OpenTelemetry)
    this method is internal, no user should be setting the OpenTelemetry as it is obtained by using GlobalOpenTelemetry.get() and there should be no other implementations but the one available in the classpath, this constructor will be removed in the future releases. Use OpenTelemetryHttpServerFilter(OpenTelemetryOptions) or OpenTelemetryHttpServerFilter() instead.
    io.servicetalk.tcp.netty.internal.TcpClientChannelInitializer(ReadOnlyTcpClientConfig, ConnectionObserver)
    Use TcpClientChannelInitializer(ReadOnlyTcpClientConfig, ConnectionObserver, ExecutionContext, boolean)
    io.servicetalk.tcp.netty.internal.TcpClientChannelInitializer(ReadOnlyTcpClientConfig, ConnectionObserver, boolean)
    Use TcpClientChannelInitializer(ReadOnlyTcpClientConfig, ConnectionObserver, ExecutionContext, boolean)
    io.servicetalk.tcp.netty.internal.TcpServerChannelInitializer(ReadOnlyTcpServerConfig, ConnectionObserver)
    Use TcpServerChannelInitializer(ReadOnlyTcpServerConfig, ConnectionObserver, ExecutionContext)
    io.servicetalk.transport.netty.internal.ConnectionObserverInitializer(ConnectionObserver, boolean, boolean)
    Use ConnectionObserverInitializer(ConnectionObserver, Function, boolean, SslConfig) instead
    io.servicetalk.transport.netty.internal.ConnectionObserverInitializer(ConnectionObserver, Function<Channel, ConnectionInfo>, boolean, boolean)
    Use ConnectionObserverInitializer(ConnectionObserver, Function, boolean, SslConfig) instead
    io.servicetalk.transport.netty.internal.IdleTimeoutInitializer(Duration)
    Use IdleTimeoutInitializer(long)
    io.servicetalk.transport.netty.internal.SniServerChannelInitializer(Mapping<String, SslContext>)
    Use SniServerChannelInitializer(Mapping, int, long).