CordaRPCClientConfiguration
Keywords: net.corda.client.rpc.CordaRPCClientConfiguration class
Date: 2023-09-18

net.corda.client.rpc

## Class CordaRPCClientConfiguration

- net.corda.client.rpc.CordaRPCClientConfiguration

-     public class CordaRPCClientConfiguration

  Can be used to configure the RPC client connection.

- - ### Field Detail

    - #### DEFAULT

          @JvmField
           @NotNull
          public static CordaRPCClientConfiguration DEFAULT

      Provides an instance of this class with the parameters set to our recommended defaults.

    - #### Companion

          public static net.corda.client.rpc.CordaRPCClientConfiguration.Companion Companion

  - ### Constructor Detail

    - #### CordaRPCClientConfiguration

          @JvmOverloads
          public CordaRPCClientConfiguration(@NotNull
                                                           java.time.Duration connectionMaxRetryInterval,
                                                           int minimumServerProtocolVersion,
                                                           boolean trackRpcCallSites,
                                                           @NotNull
                                                           java.time.Duration reapInterval,
                                                           int observationExecutorPoolSize,
                                                           @NotNull
                                                           java.time.Duration connectionRetryInterval,
                                                           double connectionRetryIntervalMultiplier,
                                                           int maxReconnectAttempts,
                                                           int maxFileSize,
                                                           @NotNull
                                                           java.time.Duration deduplicationCacheExpiry,
                                                           boolean openTelemetryEnabled,
                                                           boolean simpleLogTelemetryEnabled,
                                                           boolean spanStartEndEventsEnabled,
                                                           boolean copyBaggageToTags)

      Can be used to configure the RPC client connection.

      Parameters:
        `connectionMaxRetryInterval` - The maximum retry interval for re-connections. The client will retry connections if the host is lost withever increasing spacing until the max is reached. The default is 3 minutes.
        `minimumServerProtocolVersion` -

        The minimum protocol version required from the server. This is equivalent to the node's platform version number. If this minimum version is not met, an exception will be thrown at startup. If you use features introduced in a later version, you can bump this to match the platform version you need and get an early check that runs before you do anything.

        If you leave it at the default then things will work but attempting to use an RPC added in a version later than the server supports will throw UnsupportedOperationException.

        The default value is whatever version of Corda this RPC library was shipped as a part of. Therefore if you use the RPC library from Corda 4, it will by default only connect to a node of version 4 or above.

        `trackRpcCallSites` - If set to true the client will track RPC call sites (default is false). If an error occurs subsequentlyduring the RPC or in a returned Observable stream the stack trace of the originating RPC will be shown aswell. Note that constructing call stacks is a moderately expensive operation.
        `reapInterval` - The interval of unused observable reaping. Leaked Observables (unused ones) are detected using weak referencesand are cleaned up in batches in this interval. If set too large it will waste server side resources for thisduration. If set too low it wastes client side cycles. The default is to check once per second.
        `observationExecutorPoolSize` - The number of threads to use for observations for executing Observable.onNext. This only has any effectif observableExecutor is null (which is the default). The default is 4.
        `connectionRetryInterval` - The base retry interval for reconnection attempts. The default is 5 seconds.
        `connectionRetryIntervalMultiplier` - The retry interval multiplier for exponential backoff. The default is 1.5
        `maxReconnectAttempts` - Maximum reconnect attempts on failover or disconnection.Any negative value would mean that there will be an infinite number of reconnect attempts.
        `maxFileSize` - Maximum size of RPC responses, in bytes. Default is 10mb.
        `deduplicationCacheExpiry` - The cache expiry of a deduplication watermark per client. Default is 1 day.

    - #### CordaRPCClientConfiguration

          @JvmOverloads
          public CordaRPCClientConfiguration(@NotNull
                                                           java.time.Duration connectionMaxRetryInterval,
                                                           int minimumServerProtocolVersion,
                                                           boolean trackRpcCallSites,
                                                           @NotNull
                                                           java.time.Duration reapInterval,
                                                           int observationExecutorPoolSize,
                                                           @NotNull
                                                           java.time.Duration connectionRetryInterval,
                                                           double connectionRetryIntervalMultiplier,
                                                           int maxReconnectAttempts,
                                                           int maxFileSize,
                                                           @NotNull
                                                           java.time.Duration deduplicationCacheExpiry,
                                                           boolean openTelemetryEnabled,
                                                           boolean simpleLogTelemetryEnabled,
                                                           boolean spanStartEndEventsEnabled)

      Can be used to configure the RPC client connection.

      Parameters:
        `connectionMaxRetryInterval` - The maximum retry interval for re-connections. The client will retry connections if the host is lost withever increasing spacing until the max is reached. The default is 3 minutes.
        `minimumServerProtocolVersion` -

        The minimum protocol version required from the server. This is equivalent to the node's platform version number. If this minimum version is not met, an exception will be thrown at startup. If you use features introduced in a later version, you can bump this to match the platform version you need and get an early check that runs before you do anything.

        If you leave it at the default then things will work but attempting to use an RPC added in a version later than the server supports will throw UnsupportedOperationException.

        The default value is whatever version of Corda this RPC library was shipped as a part of. Therefore if you use the RPC library from Corda 4, it will by default only connect to a node of version 4 or above.

        `trackRpcCallSites` - If set to true the client will track RPC call sites (default is false). If an error occurs subsequentlyduring the RPC or in a returned Observable stream the stack trace of the originating RPC will be shown aswell. Note that constructing call stacks is a moderately expensive operation.
        `reapInterval` - The interval of unused observable reaping. Leaked Observables (unused ones) are detected using weak referencesand are cleaned up in batches in this interval. If set too large it will waste server side resources for thisduration. If set too low it wastes client side cycles. The default is to check once per second.
        `observationExecutorPoolSize` - The number of threads to use for observations for executing Observable.onNext. This only has any effectif observableExecutor is null (which is the default). The default is 4.
        `connectionRetryInterval` - The base retry interval for reconnection attempts. The default is 5 seconds.
        `connectionRetryIntervalMultiplier` - The retry interval multiplier for exponential backoff. The default is 1.5
        `maxReconnectAttempts` - Maximum reconnect attempts on failover or disconnection.Any negative value would mean that there will be an infinite number of reconnect attempts.
        `maxFileSize` - Maximum size of RPC responses, in bytes. Default is 10mb.
        `deduplicationCacheExpiry` - The cache expiry of a deduplication watermark per client. Default is 1 day.

    - #### CordaRPCClientConfiguration

          @JvmOverloads
          public CordaRPCClientConfiguration(@NotNull
                                                           java.time.Duration connectionMaxRetryInterval,
                                                           int minimumServerProtocolVersion,
                                                           boolean trackRpcCallSites,
                                                           @NotNull
                                                           java.time.Duration reapInterval,
                                                           int observationExecutorPoolSize,
                                                           @NotNull
                                                           java.time.Duration connectionRetryInterval,
                                                           double connectionRetryIntervalMultiplier,
                                                           int maxReconnectAttempts,
                                                           int maxFileSize,
                                                           @NotNull
                                                           java.time.Duration deduplicationCacheExpiry,
                                                           boolean openTelemetryEnabled,
                                                           boolean simpleLogTelemetryEnabled)

      Can be used to configure the RPC client connection.

      Parameters:
        `connectionMaxRetryInterval` - The maximum retry interval for re-connections. The client will retry connections if the host is lost withever increasing spacing until the max is reached. The default is 3 minutes.
        `minimumServerProtocolVersion` -

        The minimum protocol version required from the server. This is equivalent to the node's platform version number. If this minimum version is not met, an exception will be thrown at startup. If you use features introduced in a later version, you can bump this to match the platform version you need and get an early check that runs before you do anything.

        If you leave it at the default then things will work but attempting to use an RPC added in a version later than the server supports will throw UnsupportedOperationException.

        The default value is whatever version of Corda this RPC library was shipped as a part of. Therefore if you use the RPC library from Corda 4, it will by default only connect to a node of version 4 or above.

        `trackRpcCallSites` - If set to true the client will track RPC call sites (default is false). If an error occurs subsequentlyduring the RPC or in a returned Observable stream the stack trace of the originating RPC will be shown aswell. Note that constructing call stacks is a moderately expensive operation.
        `reapInterval` - The interval of unused observable reaping. Leaked Observables (unused ones) are detected using weak referencesand are cleaned up in batches in this interval. If set too large it will waste server side resources for thisduration. If set too low it wastes client side cycles. The default is to check once per second.
        `observationExecutorPoolSize` - The number of threads to use for observations for executing Observable.onNext. This only has any effectif observableExecutor is null (which is the default). The default is 4.
        `connectionRetryInterval` - The base retry interval for reconnection attempts. The default is 5 seconds.
        `connectionRetryIntervalMultiplier` - The retry interval multiplier for exponential backoff. The default is 1.5
        `maxReconnectAttempts` - Maximum reconnect attempts on failover or disconnection.Any negative value would mean that there will be an infinite number of reconnect attempts.
        `maxFileSize` - Maximum size of RPC responses, in bytes. Default is 10mb.
        `deduplicationCacheExpiry` - The cache expiry of a deduplication watermark per client. Default is 1 day.

    - #### CordaRPCClientConfiguration

          @JvmOverloads
          public CordaRPCClientConfiguration(@NotNull
                                                           java.time.Duration connectionMaxRetryInterval,
                                                           int minimumServerProtocolVersion,
                                                           boolean trackRpcCallSites,
                                                           @NotNull
                                                           java.time.Duration reapInterval,
                                                           int observationExecutorPoolSize,
                                                           @NotNull
                                                           java.time.Duration connectionRetryInterval,
                                                           double connectionRetryIntervalMultiplier,
                                                           int maxReconnectAttempts,
                                                           int maxFileSize,
                                                           @NotNull
                                                           java.time.Duration deduplicationCacheExpiry,
                                                           boolean openTelemetryEnabled)

      Can be used to configure the RPC client connection.

      Parameters:
        `connectionMaxRetryInterval` - The maximum retry interval for re-connections. The client will retry connections if the host is lost withever increasing spacing until the max is reached. The default is 3 minutes.
        `minimumServerProtocolVersion` -

        The minimum protocol version required from the server. This is equivalent to the node's platform version number. If this minimum version is not met, an exception will be thrown at startup. If you use features introduced in a later version, you can bump this to match the platform version you need and get an early check that runs before you do anything.

        If you leave it at the default then things will work but attempting to use an RPC added in a version later than the server supports will throw UnsupportedOperationException.

        The default value is whatever version of Corda this RPC library was shipped as a part of. Therefore if you use the RPC library from Corda 4, it will by default only connect to a node of version 4 or above.

        `trackRpcCallSites` - If set to true the client will track RPC call sites (default is false). If an error occurs subsequentlyduring the RPC or in a returned Observable stream the stack trace of the originating RPC will be shown aswell. Note that constructing call stacks is a moderately expensive operation.
        `reapInterval` - The interval of unused observable reaping. Leaked Observables (unused ones) are detected using weak referencesand are cleaned up in batches in this interval. If set too large it will waste server side resources for thisduration. If set too low it wastes client side cycles. The default is to check once per second.
        `observationExecutorPoolSize` - The number of threads to use for observations for executing Observable.onNext. This only has any effectif observableExecutor is null (which is the default). The default is 4.
        `connectionRetryInterval` - The base retry interval for reconnection attempts. The default is 5 seconds.
        `connectionRetryIntervalMultiplier` - The retry interval multiplier for exponential backoff. The default is 1.5
        `maxReconnectAttempts` - Maximum reconnect attempts on failover or disconnection.Any negative value would mean that there will be an infinite number of reconnect attempts.
        `maxFileSize` - Maximum size of RPC responses, in bytes. Default is 10mb.
        `deduplicationCacheExpiry` - The cache expiry of a deduplication watermark per client. Default is 1 day.

    - #### CordaRPCClientConfiguration

          @JvmOverloads
          public CordaRPCClientConfiguration(@NotNull
                                                           java.time.Duration connectionMaxRetryInterval,
                                                           int minimumServerProtocolVersion,
                                                           boolean trackRpcCallSites,
                                                           @NotNull
                                                           java.time.Duration reapInterval,
                                                           int observationExecutorPoolSize,
                                                           @NotNull
                                                           java.time.Duration connectionRetryInterval,
                                                           double connectionRetryIntervalMultiplier,
                                                           int maxReconnectAttempts,
                                                           int maxFileSize,
                                                           @NotNull
                                                           java.time.Duration deduplicationCacheExpiry)

      Can be used to configure the RPC client connection.

      Parameters:
        `connectionMaxRetryInterval` - The maximum retry interval for re-connections. The client will retry connections if the host is lost withever increasing spacing until the max is reached. The default is 3 minutes.
        `minimumServerProtocolVersion` -

        The minimum protocol version required from the server. This is equivalent to the node's platform version number. If this minimum version is not met, an exception will be thrown at startup. If you use features introduced in a later version, you can bump this to match the platform version you need and get an early check that runs before you do anything.

        If you leave it at the default then things will work but attempting to use an RPC added in a version later than the server supports will throw UnsupportedOperationException.

        The default value is whatever version of Corda this RPC library was shipped as a part of. Therefore if you use the RPC library from Corda 4, it will by default only connect to a node of version 4 or above.

        `trackRpcCallSites` - If set to true the client will track RPC call sites (default is false). If an error occurs subsequentlyduring the RPC or in a returned Observable stream the stack trace of the originating RPC will be shown aswell. Note that constructing call stacks is a moderately expensive operation.
        `reapInterval` - The interval of unused observable reaping. Leaked Observables (unused ones) are detected using weak referencesand are cleaned up in batches in this interval. If set too large it will waste server side resources for thisduration. If set too low it wastes client side cycles. The default is to check once per second.
        `observationExecutorPoolSize` - The number of threads to use for observations for executing Observable.onNext. This only has any effectif observableExecutor is null (which is the default). The default is 4.
        `connectionRetryInterval` - The base retry interval for reconnection attempts. The default is 5 seconds.
        `connectionRetryIntervalMultiplier` - The retry interval multiplier for exponential backoff. The default is 1.5
        `maxReconnectAttempts` - Maximum reconnect attempts on failover or disconnection.Any negative value would mean that there will be an infinite number of reconnect attempts.
        `maxFileSize` - Maximum size of RPC responses, in bytes. Default is 10mb.
        `deduplicationCacheExpiry` - The cache expiry of a deduplication watermark per client. Default is 1 day.

    - #### CordaRPCClientConfiguration

          @JvmOverloads
          public CordaRPCClientConfiguration(@NotNull
                                                           java.time.Duration connectionMaxRetryInterval,
                                                           int minimumServerProtocolVersion,
                                                           boolean trackRpcCallSites,
                                                           @NotNull
                                                           java.time.Duration reapInterval,
                                                           int observationExecutorPoolSize,
                                                           @NotNull
                                                           java.time.Duration connectionRetryInterval,
                                                           double connectionRetryIntervalMultiplier,
                                                           int maxReconnectAttempts,
                                                           int maxFileSize)

      Can be used to configure the RPC client connection.

      Parameters:
        `connectionMaxRetryInterval` - The maximum retry interval for re-connections. The client will retry connections if the host is lost withever increasing spacing until the max is reached. The default is 3 minutes.
        `minimumServerProtocolVersion` -

        The minimum protocol version required from the server. This is equivalent to the node's platform version number. If this minimum version is not met, an exception will be thrown at startup. If you use features introduced in a later version, you can bump this to match the platform version you need and get an early check that runs before you do anything.

        If you leave it at the default then things will work but attempting to use an RPC added in a version later than the server supports will throw UnsupportedOperationException.

        The default value is whatever version of Corda this RPC library was shipped as a part of. Therefore if you use the RPC library from Corda 4, it will by default only connect to a node of version 4 or above.

        `trackRpcCallSites` - If set to true the client will track RPC call sites (default is false). If an error occurs subsequentlyduring the RPC or in a returned Observable stream the stack trace of the originating RPC will be shown aswell. Note that constructing call stacks is a moderately expensive operation.
        `reapInterval` - The interval of unused observable reaping. Leaked Observables (unused ones) are detected using weak referencesand are cleaned up in batches in this interval. If set too large it will waste server side resources for thisduration. If set too low it wastes client side cycles. The default is to check once per second.
        `observationExecutorPoolSize` - The number of threads to use for observations for executing Observable.onNext. This only has any effectif observableExecutor is null (which is the default). The default is 4.
        `connectionRetryInterval` - The base retry interval for reconnection attempts. The default is 5 seconds.
        `connectionRetryIntervalMultiplier` - The retry interval multiplier for exponential backoff. The default is 1.5
        `maxReconnectAttempts` - Maximum reconnect attempts on failover or disconnection.Any negative value would mean that there will be an infinite number of reconnect attempts.
        `maxFileSize` - Maximum size of RPC responses, in bytes. Default is 10mb.

    - #### CordaRPCClientConfiguration

          @JvmOverloads
          public CordaRPCClientConfiguration(@NotNull
                                                           java.time.Duration connectionMaxRetryInterval,
                                                           int minimumServerProtocolVersion,
                                                           boolean trackRpcCallSites,
                                                           @NotNull
                                                           java.time.Duration reapInterval,
                                                           int observationExecutorPoolSize,
                                                           @NotNull
                                                           java.time.Duration connectionRetryInterval,
                                                           double connectionRetryIntervalMultiplier,
                                                           int maxReconnectAttempts)

      Can be used to configure the RPC client connection.

      Parameters:
        `connectionMaxRetryInterval` - The maximum retry interval for re-connections. The client will retry connections if the host is lost withever increasing spacing until the max is reached. The default is 3 minutes.
        `minimumServerProtocolVersion` -

        The minimum protocol version required from the server. This is equivalent to the node's platform version number. If this minimum version is not met, an exception will be thrown at startup. If you use features introduced in a later version, you can bump this to match the platform version you need and get an early check that runs before you do anything.

        If you leave it at the default then things will work but attempting to use an RPC added in a version later than the server supports will throw UnsupportedOperationException.

        The default value is whatever version of Corda this RPC library was shipped as a part of. Therefore if you use the RPC library from Corda 4, it will by default only connect to a node of version 4 or above.

        `trackRpcCallSites` - If set to true the client will track RPC call sites (default is false). If an error occurs subsequentlyduring the RPC or in a returned Observable stream the stack trace of the originating RPC will be shown aswell. Note that constructing call stacks is a moderately expensive operation.
        `reapInterval` - The interval of unused observable reaping. Leaked Observables (unused ones) are detected using weak referencesand are cleaned up in batches in this interval. If set too large it will waste server side resources for thisduration. If set too low it wastes client side cycles. The default is to check once per second.
        `observationExecutorPoolSize` - The number of threads to use for observations for executing Observable.onNext. This only has any effectif observableExecutor is null (which is the default). The default is 4.
        `connectionRetryInterval` - The base retry interval for reconnection attempts. The default is 5 seconds.
        `connectionRetryIntervalMultiplier` - The retry interval multiplier for exponential backoff. The default is 1.5
        `maxReconnectAttempts` - Maximum reconnect attempts on failover or disconnection.Any negative value would mean that there will be an infinite number of reconnect attempts.

    - #### CordaRPCClientConfiguration

          @JvmOverloads
          public CordaRPCClientConfiguration(@NotNull
                                                           java.time.Duration connectionMaxRetryInterval,
                                                           int minimumServerProtocolVersion,
                                                           boolean trackRpcCallSites,
                                                           @NotNull
                                                           java.time.Duration reapInterval,
                                                           int observationExecutorPoolSize,
                                                           @NotNull
                                                           java.time.Duration connectionRetryInterval,
                                                           double connectionRetryIntervalMultiplier)

      Can be used to configure the RPC client connection.

      Parameters:
        `connectionMaxRetryInterval` - The maximum retry interval for re-connections. The client will retry connections if the host is lost withever increasing spacing until the max is reached. The default is 3 minutes.
        `minimumServerProtocolVersion` -

        The minimum protocol version required from the server. This is equivalent to the node's platform version number. If this minimum version is not met, an exception will be thrown at startup. If you use features introduced in a later version, you can bump this to match the platform version you need and get an early check that runs before you do anything.

        If you leave it at the default then things will work but attempting to use an RPC added in a version later than the server supports will throw UnsupportedOperationException.

        The default value is whatever version of Corda this RPC library was shipped as a part of. Therefore if you use the RPC library from Corda 4, it will by default only connect to a node of version 4 or above.

        `trackRpcCallSites` - If set to true the client will track RPC call sites (default is false). If an error occurs subsequentlyduring the RPC or in a returned Observable stream the stack trace of the originating RPC will be shown aswell. Note that constructing call stacks is a moderately expensive operation.
        `reapInterval` - The interval of unused observable reaping. Leaked Observables (unused ones) are detected using weak referencesand are cleaned up in batches in this interval. If set too large it will waste server side resources for thisduration. If set too low it wastes client side cycles. The default is to check once per second.
        `observationExecutorPoolSize` - The number of threads to use for observations for executing Observable.onNext. This only has any effectif observableExecutor is null (which is the default). The default is 4.
        `connectionRetryInterval` - The base retry interval for reconnection attempts. The default is 5 seconds.
        `connectionRetryIntervalMultiplier` - The retry interval multiplier for exponential backoff. The default is 1.5

    - #### CordaRPCClientConfiguration

          @JvmOverloads
          public CordaRPCClientConfiguration(@NotNull
                                                           java.time.Duration connectionMaxRetryInterval,
                                                           int minimumServerProtocolVersion,
                                                           boolean trackRpcCallSites,
                                                           @NotNull
                                                           java.time.Duration reapInterval,
                                                           int observationExecutorPoolSize,
                                                           @NotNull
                                                           java.time.Duration connectionRetryInterval)

      Can be used to configure the RPC client connection.

      Parameters:
        `connectionMaxRetryInterval` - The maximum retry interval for re-connections. The client will retry connections if the host is lost withever increasing spacing until the max is reached. The default is 3 minutes.
        `minimumServerProtocolVersion` -

        The minimum protocol version required from the server. This is equivalent to the node's platform version number. If this minimum version is not met, an exception will be thrown at startup. If you use features introduced in a later version, you can bump this to match the platform version you need and get an early check that runs before you do anything.

        If you leave it at the default then things will work but attempting to use an RPC added in a version later than the server supports will throw UnsupportedOperationException.

        The default value is whatever version of Corda this RPC library was shipped as a part of. Therefore if you use the RPC library from Corda 4, it will by default only connect to a node of version 4 or above.

        `trackRpcCallSites` - If set to true the client will track RPC call sites (default is false). If an error occurs subsequentlyduring the RPC or in a returned Observable stream the stack trace of the originating RPC will be shown aswell. Note that constructing call stacks is a moderately expensive operation.
        `reapInterval` - The interval of unused observable reaping. Leaked Observables (unused ones) are detected using weak referencesand are cleaned up in batches in this interval. If set too large it will waste server side resources for thisduration. If set too low it wastes client side cycles. The default is to check once per second.
        `observationExecutorPoolSize` - The number of threads to use for observations for executing Observable.onNext. This only has any effectif observableExecutor is null (which is the default). The default is 4.
        `connectionRetryInterval` - The base retry interval for reconnection attempts. The default is 5 seconds.

    - #### CordaRPCClientConfiguration

          @JvmOverloads
          public CordaRPCClientConfiguration(@NotNull
                                                           java.time.Duration connectionMaxRetryInterval,
                                                           int minimumServerProtocolVersion,
                                                           boolean trackRpcCallSites,
                                                           @NotNull
                                                           java.time.Duration reapInterval,
                                                           int observationExecutorPoolSize)

      Can be used to configure the RPC client connection.

      Parameters:
        `connectionMaxRetryInterval` - The maximum retry interval for re-connections. The client will retry connections if the host is lost withever increasing spacing until the max is reached. The default is 3 minutes.
        `minimumServerProtocolVersion` -

        The minimum protocol version required from the server. This is equivalent to the node's platform version number. If this minimum version is not met, an exception will be thrown at startup. If you use features introduced in a later version, you can bump this to match the platform version you need and get an early check that runs before you do anything.

        If you leave it at the default then things will work but attempting to use an RPC added in a version later than the server supports will throw UnsupportedOperationException.

        The default value is whatever version of Corda this RPC library was shipped as a part of. Therefore if you use the RPC library from Corda 4, it will by default only connect to a node of version 4 or above.

        `trackRpcCallSites` - If set to true the client will track RPC call sites (default is false). If an error occurs subsequentlyduring the RPC or in a returned Observable stream the stack trace of the originating RPC will be shown aswell. Note that constructing call stacks is a moderately expensive operation.
        `reapInterval` - The interval of unused observable reaping. Leaked Observables (unused ones) are detected using weak referencesand are cleaned up in batches in this interval. If set too large it will waste server side resources for thisduration. If set too low it wastes client side cycles. The default is to check once per second.
        `observationExecutorPoolSize` - The number of threads to use for observations for executing Observable.onNext. This only has any effectif observableExecutor is null (which is the default). The default is 4.

    - #### CordaRPCClientConfiguration

          @JvmOverloads
          public CordaRPCClientConfiguration(@NotNull
                                                           java.time.Duration connectionMaxRetryInterval,
                                                           int minimumServerProtocolVersion,
                                                           boolean trackRpcCallSites,
                                                           @NotNull
                                                           java.time.Duration reapInterval,
                                                           int observationExecutorPoolSize)

      Can be used to configure the RPC client connection.

      Parameters:
        `connectionMaxRetryInterval` - The maximum retry interval for re-connections. The client will retry connections if the host is lost withever increasing spacing until the max is reached. The default is 3 minutes.
        `minimumServerProtocolVersion` -

        The minimum protocol version required from the server. This is equivalent to the node's platform version number. If this minimum version is not met, an exception will be thrown at startup. If you use features introduced in a later version, you can bump this to match the platform version you need and get an early check that runs before you do anything.

        If you leave it at the default then things will work but attempting to use an RPC added in a version later than the server supports will throw UnsupportedOperationException.

        The default value is whatever version of Corda this RPC library was shipped as a part of. Therefore if you use the RPC library from Corda 4, it will by default only connect to a node of version 4 or above.

        `trackRpcCallSites` - If set to true the client will track RPC call sites (default is false). If an error occurs subsequentlyduring the RPC or in a returned Observable stream the stack trace of the originating RPC will be shown aswell. Note that constructing call stacks is a moderately expensive operation.
        `reapInterval` - The interval of unused observable reaping. Leaked Observables (unused ones) are detected using weak referencesand are cleaned up in batches in this interval. If set too large it will waste server side resources for thisduration. If set too low it wastes client side cycles. The default is to check once per second.
        `observationExecutorPoolSize` - The number of threads to use for observations for executing Observable.onNext. This only has any effectif observableExecutor is null (which is the default). The default is 4.

    - #### CordaRPCClientConfiguration

          @JvmOverloads
          public CordaRPCClientConfiguration(@NotNull
                                                           java.time.Duration connectionMaxRetryInterval,
                                                           int minimumServerProtocolVersion,
                                                           boolean trackRpcCallSites,
                                                           @NotNull
                                                           java.time.Duration reapInterval)

      Can be used to configure the RPC client connection.

      Parameters:
        `connectionMaxRetryInterval` - The maximum retry interval for re-connections. The client will retry connections if the host is lost withever increasing spacing until the max is reached. The default is 3 minutes.
        `minimumServerProtocolVersion` -

        The minimum protocol version required from the server. This is equivalent to the node's platform version number. If this minimum version is not met, an exception will be thrown at startup. If you use features introduced in a later version, you can bump this to match the platform version you need and get an early check that runs before you do anything.

        If you leave it at the default then things will work but attempting to use an RPC added in a version later than the server supports will throw UnsupportedOperationException.

        The default value is whatever version of Corda this RPC library was shipped as a part of. Therefore if you use the RPC library from Corda 4, it will by default only connect to a node of version 4 or above.

        `trackRpcCallSites` - If set to true the client will track RPC call sites (default is false). If an error occurs subsequentlyduring the RPC or in a returned Observable stream the stack trace of the originating RPC will be shown aswell. Note that constructing call stacks is a moderately expensive operation.
        `reapInterval` - The interval of unused observable reaping. Leaked Observables (unused ones) are detected using weak referencesand are cleaned up in batches in this interval. If set too large it will waste server side resources for thisduration. If set too low it wastes client side cycles. The default is to check once per second.

    - #### CordaRPCClientConfiguration

          @JvmOverloads
          public CordaRPCClientConfiguration(@NotNull
                                                           java.time.Duration connectionMaxRetryInterval,
                                                           int minimumServerProtocolVersion,
                                                           boolean trackRpcCallSites)

      Can be used to configure the RPC client connection.

      Parameters:
        `connectionMaxRetryInterval` - The maximum retry interval for re-connections. The client will retry connections if the host is lost withever increasing spacing until the max is reached. The default is 3 minutes.
        `minimumServerProtocolVersion` -

        The minimum protocol version required from the server. This is equivalent to the node's platform version number. If this minimum version is not met, an exception will be thrown at startup. If you use features introduced in a later version, you can bump this to match the platform version you need and get an early check that runs before you do anything.

        If you leave it at the default then things will work but attempting to use an RPC added in a version later than the server supports will throw UnsupportedOperationException.

        The default value is whatever version of Corda this RPC library was shipped as a part of. Therefore if you use the RPC library from Corda 4, it will by default only connect to a node of version 4 or above.

        `trackRpcCallSites` - If set to true the client will track RPC call sites (default is false). If an error occurs subsequentlyduring the RPC or in a returned Observable stream the stack trace of the originating RPC will be shown aswell. Note that constructing call stacks is a moderately expensive operation.

    - #### CordaRPCClientConfiguration

          @JvmOverloads
          public CordaRPCClientConfiguration(@NotNull
                                                           java.time.Duration connectionMaxRetryInterval,
                                                           int minimumServerProtocolVersion)

      Can be used to configure the RPC client connection.

      Parameters:
        `connectionMaxRetryInterval` - The maximum retry interval for re-connections. The client will retry connections if the host is lost withever increasing spacing until the max is reached. The default is 3 minutes.
        `minimumServerProtocolVersion` -

        The minimum protocol version required from the server. This is equivalent to the node's platform version number. If this minimum version is not met, an exception will be thrown at startup. If you use features introduced in a later version, you can bump this to match the platform version you need and get an early check that runs before you do anything.

        If you leave it at the default then things will work but attempting to use an RPC added in a version later than the server supports will throw UnsupportedOperationException.

        The default value is whatever version of Corda this RPC library was shipped as a part of. Therefore if you use the RPC library from Corda 4, it will by default only connect to a node of version 4 or above.

    - #### CordaRPCClientConfiguration

          @JvmOverloads
          public CordaRPCClientConfiguration(@NotNull
                                                           java.time.Duration connectionMaxRetryInterval)

      Can be used to configure the RPC client connection.

      Parameters:
        `connectionMaxRetryInterval` - The maximum retry interval for re-connections. The client will retry connections if the host is lost withever increasing spacing until the max is reached. The default is 3 minutes.

    - #### CordaRPCClientConfiguration

          @JvmOverloads
          public CordaRPCClientConfiguration()

      Can be used to configure the RPC client connection.

  - ### Method Detail

    - #### copy

          @NotNull
          public CordaRPCClientConfiguration copy(@NotNull
                                                           java.time.Duration connectionMaxRetryInterval,
                                                           int minimumServerProtocolVersion,
                                                           boolean trackRpcCallSites,
                                                           @NotNull
                                                           java.time.Duration reapInterval,
                                                           int observationExecutorPoolSize,
                                                           int cacheConcurrencyLevel,
                                                           @NotNull
                                                           java.time.Duration connectionRetryInterval,
                                                           double connectionRetryIntervalMultiplier,
                                                           int maxReconnectAttempts,
                                                           int maxFileSize,
                                                           @NotNull
                                                           java.time.Duration deduplicationCacheExpiry,
                                                           boolean openTelemetryEnabled,
                                                           boolean simpleLogTelemetryEnabled,
                                                           boolean spanStartEndEventsEnabled,
                                                           boolean copyBaggageToTags)

    - #### equals

          public boolean equals(@Nullable
                                java.lang.Object other)

    - #### hashCode

          public int hashCode()

    - #### toString

          @NotNull
          public java.lang.String toString()

    - #### component1

          @Deprecated
           @NotNull
          public java.time.Duration component1()

      Deprecated.

    - #### getConnectionMaxRetryInterval

          @NotNull
          public java.time.Duration getConnectionMaxRetryInterval()

      The maximum retry interval for re-connections.

      The client will retry connections if the host is lost withever increasing spacing until the max is reached. The default is 3 minutes.

    - #### getMinimumServerProtocolVersion

          public int getMinimumServerProtocolVersion()

      The minimum protocol version required from the server. This is equivalent to the node's platform version number. If this minimum version is not met, an exception will be thrown at startup. If you use features introduced in a later version, you can bump this to match the platform version you need and get an early check that runs before you do anything.

      If you leave it at the default then things will work but attempting to use an RPC added in a version later than the server supports will throw UnsupportedOperationException.

      The default value is whatever version of Corda this RPC library was shipped as a part of. Therefore if you use the RPC library from Corda 4, it will by default only connect to a node of version 4 or above.

      See Also:
        UnsupportedOperationException

    - #### getTrackRpcCallSites

          public boolean getTrackRpcCallSites()

      If set to true the client will track RPC call sites

      (default is false). If an error occurs subsequentlyduring the RPC or in a returned Observable stream the stack trace of the originating RPC will be shown aswell. Note that constructing call stacks is a moderately expensive operation.

    - #### getReapInterval

          @NotNull
          public java.time.Duration getReapInterval()

      The interval of unused observable reaping.

      Leaked Observables (unused ones) are detected using weak referencesand are cleaned up in batches in this interval. If set too large it will waste server side resources for thisduration. If set too low it wastes client side cycles. The default is to check once per second.

    - #### getObservationExecutorPoolSize

          public int getObservationExecutorPoolSize()

      The number of threads to use for observations for executing

      Observable.onNext. This only has any effectif observableExecutor is null (which is the default). The default is 4.

      See Also:
        Observable.onNext, observableExecutor

    - #### getConnectionRetryInterval

          @NotNull
          public java.time.Duration getConnectionRetryInterval()

      The base retry interval for reconnection attempts.

      The default is 5 seconds.

    - #### getConnectionRetryIntervalMultiplier

          public double getConnectionRetryIntervalMultiplier()

      The retry interval multiplier for exponential backoff.

      The default is 1.5

    - #### getMaxReconnectAttempts

          public int getMaxReconnectAttempts()

      Maximum reconnect attempts on failover or disconnection.

      Any negative value would mean that there will be an infinite number of reconnect attempts.

    - #### getMaxFileSize

          public int getMaxFileSize()

      Maximum size of RPC responses,

      in bytes. Default is 10mb.

    - #### getDeduplicationCacheExpiry

          @NotNull
          public java.time.Duration getDeduplicationCacheExpiry()

      The cache expiry of a deduplication watermark per client.

      Default is 1 day.

    - #### getOpenTelemetryEnabled

          public boolean getOpenTelemetryEnabled()

    - #### getSimpleLogTelemetryEnabled

          public boolean getSimpleLogTelemetryEnabled()

    - #### getSpanStartEndEventsEnabled

          public boolean getSpanStartEndEventsEnabled()

    - #### getCopyBaggageToTags

          public boolean getCopyBaggageToTags()