Rabbitmq Stream Dotnet Client Versions Save

RabbitMQ client for the stream protocol

v1.8.3

1 month ago

Bug Fixes

Full Changelog: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/compare/v1.8.2...v1.8.3

v1.8.2

2 months ago

Enhancements

Bug Fixes

New Contributors

Thank you to:

And to @vivek-singh2 for testing the client

Full Changelog: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/compare/v1.8.1...v1.8.2

v1.8.1

2 months ago

Bug fix

Full Changelog: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/compare/v1.8.0...v1.8.1

This version is a bug fix for the 1.8.0 Please read the full release notes here: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/releases/tag/v1.8.0

v1.8.0

3 months ago

(Below, you can find all the changes/PRs)

What's new in 1.8

The 1.8 focus are:

  • Multiple Consumers and Producers per connection
  • Improve the reconnection for stream and super stream.

The high-level classes Consumer and Producer don't introduce breaking changes.
The RawSuperStream* classes change the default behaviour. Please take a look at the section 3.

Main changes:

1. Multiple Consumers and Producers per connection

The RabbitMQ stream protocol supports multi-producers and multi-consumers per TCP Connection. This version introduces the connection pool for Consumers and Producers.

There is a new ConnectionPoolConfig setting:

new StreamSystemConfig {
  ConnectionPoolConfig = new ConnectionPoolConfig()
 {
  ConsumersPerConnection = 10, 
   ProducersPerConnection = 10, 
 }
};

ConsumersPerConnection == The number of consumers per connection min 1 max 200 default is 1
ProducersPerConnection == The number of producers per connection min 1 max 200 default is 1

Each connection can handle different streams; see the image:

Screenshot 2023-12-18 at 10 18 05

Performances

Sharing the same connection for multiple streams reduces the number of connections, but it could impact the performances:

  • Consumer side. If one consumer is slow, it can also affect the other consumers
  • Producer side: If all the producers are at full rate, it can reduce the performances

The proper parameter depends on your environment.

Tip

You can use different StreamSystemConfig like:

configToReduceTheConnections = new StreamSystemConfig{
 ConnectionPoolConfig = new ConnectionPoolConfig() {
    ConsumersPerConnection = 50, // high value 
    ProducersPerConnection = 50,  // high value
  }
}

configToIncreaseThePerformances = new StreamSystemConfig{
 ConnectionPoolConfig = new ConnectionPoolConfig() {
		ConsumersPerConnection = 1, // low value 
		ProducersPerConnection = 1,  // low value
  }
}

There are many combinations from 1 to 200.

2. Improve the reconnections

Handle streamNotAvailable, Add disconnection Info: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/343

Improve the super stream reconnection: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/344

Increase the backoff strategy time: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/345

Please follow this document If you want to know more about what happens during a broker restart.

The focus is to improve the reconnection during the cluster restart.

3. Raw Super stream events

Removed the auto-reconnect. The RawSuperStreamProducer and RawSuperStreamConsumer classes now expose two events:

https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/344

**NOTE: If you are using these classes, the auto-reconnect is removed to be compliant with all the Raw* classes. **

You should use Consumer and Producer unless for a specific use case.

For Raw* users:

  • Super Stream: during the disconnection, it is possible to understand the disconnection cause and reconnect the stream like:
var consumer = await system.CreateSuperStreamConsumer(configuration);
        var completed = new TaskCompletionSource<bool>();
        configuration.ConnectionClosedHandler = async (reason, stream) =>
        {
            if (reason == ConnectionClosedReason.Unexpected)
            {
                await consumer.ReconnectPartition(
                    await system.StreamInfo(stream).ConfigureAwait(false)
                );
                completed.SetResult(true);
            }
        };

The same is true for the standard consumer.

  • Metadata update
 MetadataHandler = async update =>
 {
    await consumer.ReconnectPartition(
                    await system.StreamInfo(stream).ConfigureAwait(false));
                        
 }

4. Add events to Producer and Consumer classes

See: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/349

See also: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/tree/main/docs/ReliableClient where you can find an example of how to use StatusChanged

 producerConfig.StatusChanged += (status) =>
  {
   var streamInfo = status.Partition is not null
      ? $" Partition {status.Partition} of super stream: {status.Stream}"
      : $"Stream: {status.Stream}";

       lp.LogInformation("Producer: {Id} - status changed from {From} to {To}. {Info}",
                              status.Identifier,
                              status.From,
                              status.To, streamInfo);

       if (status.To == ReliableEntityStatus.Open)
       {
          publishEvent.Set();
       }
       else
       {
          publishEvent.Reset();
         }};

5. Update Secret

See https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/342

6. SuperStream Creation/Deletion

See: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/357

There are two ways to create the super-stream:

  1. Based on partitions with:
const string SuperStream = "my-first-system-super-stream";
var spec = new PartitionsSuperStreamSpec(SuperStream, 2);
await system.CreateSuperStream(spec);
  1. Based on keys with:
const string SuperStream = "countries";
var system = await StreamSystem.Create(new StreamSystemConfig());
var conf = new BindingsSuperStreamSpec(SuperStream, new[] { "italy", "france", "spain", "germany", "uk" });
await system.CreateSuperStream(conf);

Enhancements

Bug fix

New Contributors

Full Changelog: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/compare/v1.7.4...v1.8.0

v1.8.0-rc.3

3 months ago

Enhancements

Full Changelog: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/compare/v1.8.0-rc.2...v1.8.0-rc.3

What's new in 1.8

The 1.8 focus are:

  • Multiple Consumers and Producers per connection
  • Improve the reconnection for stream and super stream.

The high-level classes Consumer and Producer don't introduce breaking changes.
The RawSuperStream* classes change the default behaviour. Please take a look at the section 3.

1. Multiple Consumers and Producers per connection

The RabbitMQ stream protocol supports multi-producers and multi-consumers per TCP Connection. This version introduces the connection pool for Consumers and Producers.

There is a new ConnectionPoolConfig setting:

new StreamSystemConfig {
  ConnectionPoolConfig = new ConnectionPoolConfig()
 {
  ConsumersPerConnection = 10, 
   ProducersPerConnection = 10, 
 }
};

ConsumersPerConnection == The number of consumers per connection min 1 max 200 default is 1
ProducersPerConnection == The number of producers per connection min 1 max 200 default is 1

Each connection can handle different streams; see the image:

Screenshot 2023-12-18 at 10 18 05

Performances

Sharing the same connection for multiple streams reduces the number of connections, but it could impact the performances:

  • Consumer side. If one consumer is slow, it can also affect the other consumers
  • Producer side: If all the producers are at full rate, it can reduce the performances

The proper parameter depends on your environment.

Tip

You can use different StreamSystemConfig like:

configToReduceTheConnections = new StreamSystemConfig{
 ConnectionPoolConfig = new ConnectionPoolConfig() {
    ConsumersPerConnection = 50, // high value 
    ProducersPerConnection = 50,  // high value
  }
}

configToIncreaseThePerformances = new StreamSystemConfig{
 ConnectionPoolConfig = new ConnectionPoolConfig() {
		ConsumersPerConnection = 1, // low value 
		ProducersPerConnection = 1,  // low value
  }
}

There are many combinations from 1 to 200.

2. Improve the reconnections

Handle streamNotAvailable, Add disconnection Info: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/343

Improve the super stream reconnection: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/344

Increase the backoff strategy time: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/345

Please follow this document If you want to know more about what happens during a broker restart.

The focus is to improve the reconnection during the cluster restart.

3. Raw Super stream events

Removed the auto-reconnect. The RawSuperStreamProducer and RawSuperStreamConsumer classes now expose two events:

https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/344

**NOTE: If you are using these classes, the auto-reconnect is removed to be compliant with all the Raw* classes. **

You should use Consumer and Producer unless for a specific use case.

For Raw* users:

  • Super Stream: during the disconnection, it is possible to understand the disconnection cause and reconnect the stream like:
var consumer = await system.CreateSuperStreamConsumer(configuration);
        var completed = new TaskCompletionSource<bool>();
        configuration.ConnectionClosedHandler = async (reason, stream) =>
        {
            if (reason == ConnectionClosedReason.Unexpected)
            {
                await consumer.ReconnectPartition(
                    await system.StreamInfo(stream).ConfigureAwait(false)
                );
                completed.SetResult(true);
            }
        };

The same is true for the standard consumer.

  • Metadata update
 MetadataHandler = async update =>
 {
    await consumer.ReconnectPartition(
                    await system.StreamInfo(stream).ConfigureAwait(false));
                        
 }

4. Add events to Producer and Consumer classes

See: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/349

See also: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/tree/main/docs/ReliableClient where you can find an example of how to use StatusChanged

 producerConfig.StatusChanged += (status) =>
  {
   var streamInfo = status.Partition is not null
      ? $" Partition {status.Partition} of super stream: {status.Stream}"
      : $"Stream: {status.Stream}";

       lp.LogInformation("Producer: {Id} - status changed from {From} to {To}. {Info}",
                              status.Identifier,
                              status.From,
                              status.To, streamInfo);

       if (status.To == ReliableEntityStatus.Open)
       {
          publishEvent.Set();
       }
       else
       {
          publishEvent.Reset();
         }};

5. Update Secret

See https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/342

v1.8.0-rc.2

3 months ago

Enhancements

Full Changelog: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/compare/v1.8.0-rc.1...v1.8.0-rc.2

What's new in 1.8

The 1.8 focus are:

  • Multiple Consumers and Producers per connection
  • Improve the reconnection for stream and super stream.

The high-level classes Consumer and Producer don't introduce breaking changes.
The RawSuperStream* classes change the default behaviour. Please take a look at the section 3.

1. Multiple Consumers and Producers per connection

The RabbitMQ stream protocol supports multi-producers and multi-consumers per TCP Connection. This version introduces the connection pool for Consumers and Producers.

There is a new ConnectionPoolConfig setting:

new StreamSystemConfig {
  ConnectionPoolConfig = new ConnectionPoolConfig()
 {
  ConsumersPerConnection = 10, 
   ProducersPerConnection = 10, 
 }
};

ConsumersPerConnection == The number of consumers per connection min 1 max 200 default is 1
ProducersPerConnection == The number of producers per connection min 1 max 200 default is 1

Each connection can handle different streams; see the image:

Screenshot 2023-12-18 at 10 18 05

Performances

Sharing the same connection for multiple streams reduces the number of connections, but it could impact the performances:

  • Consumer side. If one consumer is slow, it can also affect the other consumers
  • Producer side: If all the producers are at full rate, it can reduce the performances

The proper parameter depends on your environment.

Tip

You can use different StreamSystemConfig like:

configToReduceTheConnections = new StreamSystemConfig{
 ConnectionPoolConfig = new ConnectionPoolConfig() {
    ConsumersPerConnection = 50, // high value 
    ProducersPerConnection = 50,  // high value
  }
}

configToIncreaseThePerformances = new StreamSystemConfig{
 ConnectionPoolConfig = new ConnectionPoolConfig() {
		ConsumersPerConnection = 1, // low value 
		ProducersPerConnection = 1,  // low value
  }
}

There are many combinations from 1 to 200.

2. Improve the reconnections

Handle streamNotAvailable, Add disconnection Info: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/343

Improve the super stream reconnection: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/344

Increase the backoff strategy time: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/345

Please follow this document If you want to know more about what happens during a broker restart.

The focus is to improve the reconnection during the cluster restart.

3. Raw Super stream events

Removed the auto-reconnect. The RawSuperStreamProducer and RawSuperStreamConsumer classes now expose two events:

https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/344

**NOTE: If you are using these classes, the auto-reconnect is removed to be compliant with all the Raw* classes. **

You should use Consumer and Producer unless for a specific use case.

For Raw* users:

  • Super Stream: during the disconnection, it is possible to understand the disconnection cause and reconnect the stream like:
var consumer = await system.CreateSuperStreamConsumer(configuration);
        var completed = new TaskCompletionSource<bool>();
        configuration.ConnectionClosedHandler = async (reason, stream) =>
        {
            if (reason == ConnectionClosedReason.Unexpected)
            {
                await consumer.ReconnectPartition(
                    await system.StreamInfo(stream).ConfigureAwait(false)
                );
                completed.SetResult(true);
            }
        };

The same is true for the standard consumer.

  • Metadata update
 MetadataHandler = async update =>
 {
    await consumer.ReconnectPartition(
                    await system.StreamInfo(stream).ConfigureAwait(false));
                        
 }

4. Add events to Producer and Consumer classes

See: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/349

See also: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/tree/main/docs/ReliableClient where you can find an example of how to use StatusChanged

 producerConfig.StatusChanged += (status) =>
  {
   var streamInfo = status.Partition is not null
      ? $" Partition {status.Partition} of super stream: {status.Stream}"
      : $"Stream: {status.Stream}";

       lp.LogInformation("Producer: {Id} - status changed from {From} to {To}. {Info}",
                              status.Identifier,
                              status.From,
                              status.To, streamInfo);

       if (status.To == ReliableEntityStatus.Open)
       {
          publishEvent.Set();
       }
       else
       {
          publishEvent.Reset();
         }};

5. Update Secret

See https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/342

v1.8.0-rc.1

3 months ago

Enhancements

Full Changelog: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/compare/v1.8.0-beta.2...v1.8.0-rc.1

What's new in 1.8

The 1.8 focus are:

  • Multiple Consumers and Producers per connection
  • Improve the reconnection for stream and super stream.

The high-level classes Consumer and Producer don't introduce breaking changes.
The RawSuperStream* classes change the default behaviour. Please take a look at the section 3.

1. Multiple Consumers and Producers per connection

The RabbitMQ stream protocol supports multi-producers and multi-consumers per TCP Connection. This version introduces the connection pool for Consumers and Producers.

There is a new ConnectionPoolConfig setting:

new StreamSystemConfig {
  ConnectionPoolConfig = new ConnectionPoolConfig()
 {
  ConsumersPerConnection = 10, 
   ProducersPerConnection = 10, 
 }
};

ConsumersPerConnection == The number of consumers per connection min 1 max 200 default is 1
ProducersPerConnection == The number of producers per connection min 1 max 200 default is 1

Each connection can handle different streams; see the image:

Screenshot 2023-12-18 at 10 18 05

Performances

Sharing the same connection for multiple streams reduces the number of connections, but it could impact the performances:

  • Consumer side. If one consumer is slow, it can also affect the other consumers
  • Producer side: If all the producers are at full rate, it can reduce the performances

The proper parameter depends on your environment.

Tip

You can use different StreamSystemConfig like:

configToReduceTheConnections = new StreamSystemConfig{
 ConnectionPoolConfig = new ConnectionPoolConfig() {
    ConsumersPerConnection = 50, // high value 
    ProducersPerConnection = 50,  // high value
  }
}

configToIncreaseThePerformances = new StreamSystemConfig{
 ConnectionPoolConfig = new ConnectionPoolConfig() {
		ConsumersPerConnection = 1, // low value 
		ProducersPerConnection = 1,  // low value
  }
}

There are many combinations from 1 to 200.

2. Improve the reconnections

Handle streamNotAvailable, Add disconnection Info: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/343

Improve the super stream reconnection: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/344

Increase the backoff strategy time: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/345

Please follow this document If you want to know more about what happens during a broker restart.

The focus is to improve the reconnection during the cluster restart.

3. Raw Super stream events

Removed the auto-reconnect. The RawSuperStreamProducer and RawSuperStreamConsumer classes now expose two events:

https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/344

**NOTE: If you are using these classes, the auto-reconnect is removed to be compliant with all the Raw* classes. **

You should use Consumer and Producer unless for a specific use case.

For Raw* users:

  • Super Stream: during the disconnection, it is possible to understand the disconnection cause and reconnect the stream like:
var consumer = await system.CreateSuperStreamConsumer(configuration);
        var completed = new TaskCompletionSource<bool>();
        configuration.ConnectionClosedHandler = async (reason, stream) =>
        {
            if (reason == ConnectionClosedReason.Unexpected)
            {
                await consumer.ReconnectPartition(
                    await system.StreamInfo(stream).ConfigureAwait(false)
                );
                completed.SetResult(true);
            }
        };

The same is true for the standard consumer.

  • Metadata update
 MetadataHandler = async update =>
 {
    await consumer.ReconnectPartition(
                    await system.StreamInfo(stream).ConfigureAwait(false));
                        
 }

4. Add events to Producer and Consumer classes

See: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/349

See also: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/tree/main/docs/ReliableClient where you can find an example of how to use StatusChanged

 producerConfig.StatusChanged += (status) =>
  {
   var streamInfo = status.Partition is not null
      ? $" Partition {status.Partition} of super stream: {status.Stream}"
      : $"Stream: {status.Stream}";

       lp.LogInformation("Producer: {Id} - status changed from {From} to {To}. {Info}",
                              status.Identifier,
                              status.From,
                              status.To, streamInfo);

       if (status.To == ReliableEntityStatus.Open)
       {
          publishEvent.Set();
       }
       else
       {
          publishEvent.Reset();
         }};

v1.8.0-beta.2

3 months ago

Enhancements

Full Changelog: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/compare/v1.8.0-beta.1...v1.8.0-beta.2

What's new in 1.8

The 1.8 focus are:

  • Multiple Consumers and Producers per connection
  • Improve the reconnection for stream and super stream.

The high-level classes Consumer and Producer don't introduce breaking changes.
The RawSuperStream* classes change the default behaviour. Please take a look at the section 3.

1. Multiple Consumers and Producers per connection

The RabbitMQ stream protocol supports multi-producers and multi-consumers per TCP Connection. This version introduces the connection pool for Consumers and Producers.

There is a new ConnectionPoolConfig setting:

new StreamSystemConfig {
  ConnectionPoolConfig = new ConnectionPoolConfig()
 {
		ConsumersPerConnection = 10, 
		ProducersPerConnection = 10, 
 }
};

ConsumersPerConnection == The number of consumers per connection min 1 max 200 default is 1
ProducersPerConnection == The number of producers per connection min 1 max 200 default is 1

Each connection can handle different streams; see the image:

Screenshot 2023-12-18 at 10 18 05

Performances

Sharing the same connection for multiple streams reduces the number of connections, but it could impact the performances:

  • Consumer side. If one consumer is slow, it can also affect the other consumers
  • Producer side: If all the producers are at full rate, it can reduce the performances

The proper parameter depends on your environment.

Tip

You can use different StreamSystemConfig like:

configToReduceTheConnections = new StreamSystemConfig{
 ConnectionPoolConfig = new ConnectionPoolConfig() {
    ConsumersPerConnection = 50, // high value 
    ProducersPerConnection = 50,  // high value
  }
}

configToIncreaseThePerformances = new StreamSystemConfig{
 ConnectionPoolConfig = new ConnectionPoolConfig() {
		ConsumersPerConnection = 1, // low value 
		ProducersPerConnection = 1,  // low value
  }
}

There are many combinations from 1 to 200.

2. Improve the reconnections

Handle streamNotAvailable, Add disconnection Info: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/343

Improve the super stream reconnection: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/344

Increase the backoff strategy time: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/345

Please follow this document If you want to know more about what happens during a broker restart.

The focus is to improve the reconnection during the cluster restart.

3. Raw Super stream events

Removed the auto-reconnect. The RawSuperStreamProducer and RawSuperStreamConsumer classes now expose two events:

https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/pull/344

**NOTE: If you are using these classes, the auto-reconnect is removed to be compliant with all the Raw* classes. **

You should use Consumer and Producer unless for a specific use case.

For Raw* users:

  • Super Stream: during the disconnection, it is possible to understand the disconnection cause and reconnect the stream like:
var consumer = await system.CreateSuperStreamConsumer(configuration);
        var completed = new TaskCompletionSource<bool>();
        configuration.ConnectionClosedHandler = async (reason, stream) =>
        {
            if (reason == ConnectionClosedReason.Unexpected)
            {
                await consumer.ReconnectPartition(
                    await system.StreamInfo(stream).ConfigureAwait(false)
                );
                completed.SetResult(true);
            }
        };

The same is true for the standard consumer.

  • Metadata update
 MetadataHandler = async update =>
 {
    await consumer.ReconnectPartition(
                    await system.StreamInfo(stream).ConfigureAwait(false));
                        
 }

v1.8.0-beta.1

5 months ago

Enhancements

Bug Fixes

To Read

The RabbitMQ stream protocol supports multi-producers and multi-consumers per TCP Connection. This version introduces the connection pool for Consumers and Producers.

There is a new ConnectionPoolConfig setting:

       new StreamSystemConfig
        {
            ConnectionPoolConfig = new ConnectionPoolConfig()
            {
                ConsumersPerConnection = 10, 
                ProducersPerConnection = 10, 
            }
        };

ConsumersPerConnection == The number of consumers per connection min 1 max 255 default is 1 ProducersPerConnection == The number of producers per connection min 1 max 255 default is 1

Each connection can handle different streams; see the image:

Screenshot 2023-12-18 at 10 18 05

Performances

Sharing the same connection for multiple streams reduces the number of connections, but it could impact the performances:

  • Consumer side. If one consumer is slow, it can also affect the other consumers
  • Producer side: If all the producers are at full-rate, it can reduce the performances

The proper parameter depends on your environment.

Tip

You can use different StreamSystemConfig like:

configToReduceTheConnections = new StreamSystemConfig
        {
 ConnectionPoolConfig = new ConnectionPoolConfig()
            {
                ConsumersPerConnection = 50, // high value 
                ProducersPerConnection = 50,  // high value
            }
}

configToIncreaseThePerformances = new StreamSystemConfig
        {
 ConnectionPoolConfig = new ConnectionPoolConfig()
            {
                ConsumersPerConnection = 1, // low value 
                ProducersPerConnection = 1,  // low value
            }
}

There are many combinations from 1 to 255.

New Contributors

Full Changelog: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/compare/v1.7.4...v1.8.0-beta.1

v1.7.4

6 months ago

Enhancements

new ProducerConfig(system, stream)
{
   TimeoutMessageAfter = TimeSpan.FromSeconds(2), // here

Full Changelog: https://github.com/rabbitmq/rabbitmq-stream-dotnet-client/compare/v1.7.3...v1.7.4