From e3bcd644ca993a94aa8db3a9b924c1e6956ccdb8 Mon Sep 17 00:00:00 2001 From: Sergei Malafeev Date: Wed, 12 Dec 2018 13:54:13 +0800 Subject: [PATCH] upgrade lettuce to 5.1.3 Signed-off-by: Sergei Malafeev --- opentracing-redis-lettuce/pom.xml | 6 +- .../lettuce/TracingRedisAsyncCommands.java | 266 +++++++++++++++++- .../redis/lettuce/TracingRedisCommands.java | 264 ++++++++++++++++- .../TracingStatefulRedisConnection.java | 12 + 4 files changed, 544 insertions(+), 4 deletions(-) diff --git a/opentracing-redis-lettuce/pom.xml b/opentracing-redis-lettuce/pom.xml index 8c743ab..c55955e 100644 --- a/opentracing-redis-lettuce/pom.xml +++ b/opentracing-redis-lettuce/pom.xml @@ -14,7 +14,9 @@ the License. --> - + opentracing-redis-parent io.opentracing.contrib @@ -37,7 +39,7 @@ io.lettuce lettuce-core - 5.0.5.RELEASE + 5.1.3.RELEASE diff --git a/opentracing-redis-lettuce/src/main/java/io/opentracing/contrib/redis/lettuce/TracingRedisAsyncCommands.java b/opentracing-redis-lettuce/src/main/java/io/opentracing/contrib/redis/lettuce/TracingRedisAsyncCommands.java index c96aad1..b7189f9 100644 --- a/opentracing-redis-lettuce/src/main/java/io/opentracing/contrib/redis/lettuce/TracingRedisAsyncCommands.java +++ b/opentracing-redis-lettuce/src/main/java/io/opentracing/contrib/redis/lettuce/TracingRedisAsyncCommands.java @@ -17,6 +17,7 @@ import static io.opentracing.contrib.redis.common.TracingHelper.onError; import io.lettuce.core.BitFieldArgs; +import io.lettuce.core.Consumer; import io.lettuce.core.GeoArgs; import io.lettuce.core.GeoArgs.Unit; import io.lettuce.core.GeoCoordinates; @@ -30,6 +31,7 @@ import io.lettuce.core.MigrateArgs; import io.lettuce.core.Range; import io.lettuce.core.RedisFuture; +import io.lettuce.core.RestoreArgs; import io.lettuce.core.ScanArgs; import io.lettuce.core.ScanCursor; import io.lettuce.core.ScoredValue; @@ -37,10 +39,16 @@ import io.lettuce.core.ScriptOutputType; import io.lettuce.core.SetArgs; import io.lettuce.core.SortArgs; +import io.lettuce.core.StreamMessage; import io.lettuce.core.StreamScanCursor; import io.lettuce.core.TransactionResult; +import io.lettuce.core.UnblockType; import io.lettuce.core.Value; import io.lettuce.core.ValueScanCursor; +import io.lettuce.core.XAddArgs; +import io.lettuce.core.XClaimArgs; +import io.lettuce.core.XReadArgs; +import io.lettuce.core.XReadArgs.StreamOffset; import io.lettuce.core.ZAddArgs; import io.lettuce.core.ZStoreArgs; import io.lettuce.core.api.StatefulRedisConnection; @@ -460,6 +468,13 @@ public RedisFuture restore(K key, long ttl, byte[] value) { return prepareRedisFuture(commands.restore(key, ttl, value), span); } + @Override + public RedisFuture restore(K key, byte[] value, RestoreArgs args) { + Span span = helper.buildSpan("restore", key); + span.setTag("value", Arrays.toString(value)); + return prepareRedisFuture(commands.restore(key, value, args), span); + } + @Override public RedisFuture> sort(K key) { Span span = helper.buildSpan("sort", key); @@ -1095,6 +1110,20 @@ public RedisFuture sscan( return prepareRedisFuture(commands.sscan(channel, key, scanCursor), span); } + @Override + public RedisFuture>> bzpopmin(long timeout, K... keys) { + Span span = helper.buildSpan("bzpopmin", keys); + span.setTag("timeout", timeout); + return prepareRedisFuture(commands.bzpopmin(timeout, keys), span); + } + + @Override + public RedisFuture>> bzpopmax(long timeout, K... keys) { + Span span = helper.buildSpan("bzpopmax", keys); + span.setTag("timeout", timeout); + return prepareRedisFuture(commands.bzpopmax(timeout, keys), span); + } + @Override public RedisFuture zadd(K key, double score, V member) { Span span = helper.buildSpan("zadd", key); @@ -1184,7 +1213,7 @@ public RedisFuture zcount(K key, } @Override - public RedisFuture zincrby(K key, double amount, K member) { + public RedisFuture zincrby(K key, double amount, V member) { Span span = helper.buildSpan("zincrby", key); span.setTag("amount", amount); return prepareRedisFuture(commands.zincrby(key, amount, member), span); @@ -1219,6 +1248,32 @@ public RedisFuture zlexcount(K key, Range range) { return prepareRedisFuture(commands.zlexcount(key, range), span); } + @Override + public RedisFuture> zpopmin(K key) { + Span span = helper.buildSpan("zpopmin", key); + return prepareRedisFuture(commands.zpopmin(key), span); + } + + @Override + public RedisFuture>> zpopmin(K key, long count) { + Span span = helper.buildSpan("zpopmin", key); + span.setTag("count", count); + return prepareRedisFuture(commands.zpopmin(key, count), span); + } + + @Override + public RedisFuture> zpopmax(K key) { + Span span = helper.buildSpan("zpopmax", key); + return prepareRedisFuture(commands.zpopmax(key), span); + } + + @Override + public RedisFuture>> zpopmax(K key, long count) { + Span span = helper.buildSpan("zpopmax", key); + span.setTag("count", count); + return prepareRedisFuture(commands.zpopmax(key, count), span); + } + @Override public RedisFuture> zrange(K key, long start, long stop) { Span span = helper.buildSpan("zrange", key); @@ -2007,6 +2062,207 @@ public RedisFuture zunionstore(K destination, return prepareRedisFuture(commands.zunionstore(destination, storeArgs, keys), span); } + @Override + public RedisFuture xack(K key, K group, String... messageIds) { + Span span = helper.buildSpan("xack", key); + span.setTag("group", nullable(group)); + span.setTag("messageIds", Arrays.toString(messageIds)); + return prepareRedisFuture(commands.xack(key, group, messageIds), span); + } + + @Override + public RedisFuture xadd(K key, Map body) { + Span span = helper.buildSpan("xadd", key); + span.setTag("body", TracingHelper.mapToString(body)); + return prepareRedisFuture(commands.xadd(key, body), span); + } + + @Override + public RedisFuture xadd(K key, XAddArgs args, Map body) { + Span span = helper.buildSpan("xadd", key); + span.setTag("body", TracingHelper.mapToString(body)); + return prepareRedisFuture(commands.xadd(key, args, body), span); + } + + @Override + public RedisFuture xadd(K key, Object... keysAndValues) { + Span span = helper.buildSpan("xadd", key); + span.setTag("keysAndValues", Arrays.toString(keysAndValues)); + return prepareRedisFuture(commands.xadd(key, keysAndValues), span); + } + + @Override + public RedisFuture xadd(K key, XAddArgs args, Object... keysAndValues) { + Span span = helper.buildSpan("xadd", key); + span.setTag("keysAndValues", Arrays.toString(keysAndValues)); + return prepareRedisFuture(commands.xadd(key, args, keysAndValues), span); + } + + @Override + public RedisFuture>> xclaim(K key, Consumer consumer, + long minIdleTime, String... messageIds) { + Span span = helper.buildSpan("xclaim", key); + span.setTag("minIdleTime", minIdleTime); + span.setTag("consumer", nullable(consumer)); + span.setTag("messageIds", Arrays.toString(messageIds)); + return prepareRedisFuture(commands.xclaim(key, consumer, minIdleTime, messageIds), span); + } + + @Override + public RedisFuture>> xclaim(K key, Consumer consumer, XClaimArgs args, + String... messageIds) { + Span span = helper.buildSpan("xclaim", key); + span.setTag("consumer", nullable(consumer)); + span.setTag("messageIds", Arrays.toString(messageIds)); + return prepareRedisFuture(commands.xclaim(key, consumer, args, messageIds), span); + } + + @Override + public RedisFuture xdel(K key, String... messageIds) { + Span span = helper.buildSpan("xdel", key); + span.setTag("messageIds", Arrays.toString(messageIds)); + return prepareRedisFuture(commands.xdel(key, messageIds), span); + } + + @Override + public RedisFuture xgroupCreate(StreamOffset streamOffset, K group) { + Span span = helper.buildSpan("xgroupCreate"); + span.setTag("streamOffset", nullable(streamOffset)); + span.setTag("group", nullable(group)); + return prepareRedisFuture(commands.xgroupCreate(streamOffset, group), span); + } + + @Override + public RedisFuture xgroupDelconsumer(K key, Consumer consumer) { + Span span = helper.buildSpan("xgroupDelconsumer", key); + span.setTag("consumer", nullable(consumer)); + return prepareRedisFuture(commands.xgroupDelconsumer(key, consumer), span); + } + + @Override + public RedisFuture xgroupDestroy(K key, K group) { + Span span = helper.buildSpan("xgroupDestroy", key); + span.setTag("group", nullable(group)); + return prepareRedisFuture(commands.xgroupDestroy(key, group), span); + } + + @Override + public RedisFuture xgroupSetid(StreamOffset streamOffset, K group) { + Span span = helper.buildSpan("xgroupSetid"); + span.setTag("streamOffset", nullable(streamOffset)); + span.setTag("group", nullable(group)); + return prepareRedisFuture(commands.xgroupSetid(streamOffset, group), span); + } + + @Override + public RedisFuture xlen(K key) { + Span span = helper.buildSpan("xlen", key); + return prepareRedisFuture(commands.xlen(key), span); + } + + @Override + public RedisFuture> xpending(K key, K group) { + Span span = helper.buildSpan("xpending", key); + span.setTag("group", nullable(group)); + return prepareRedisFuture(commands.xpending(key, group), span); + } + + @Override + public RedisFuture> xpending(K key, K group, Range range, Limit limit) { + Span span = helper.buildSpan("xpending", key); + span.setTag("group", nullable(group)); + span.setTag("range", nullable(range)); + span.setTag("limit", nullable(limit)); + return prepareRedisFuture(commands.xpending(key, group, range, limit), span); + } + + @Override + public RedisFuture> xpending(K key, Consumer consumer, Range range, + Limit limit) { + Span span = helper.buildSpan("xpending", key); + span.setTag("consumer", nullable(consumer)); + span.setTag("range", nullable(range)); + span.setTag("limit", nullable(limit)); + return prepareRedisFuture(commands.xpending(key, consumer, range, limit), span); + } + + @Override + public RedisFuture>> xrange(K key, Range range) { + Span span = helper.buildSpan("xrange", key); + span.setTag("range", nullable(range)); + return prepareRedisFuture(commands.xrange(key, range), span); + } + + @Override + public RedisFuture>> xrange(K key, Range range, Limit limit) { + Span span = helper.buildSpan("xrange", key); + span.setTag("range", nullable(range)); + span.setTag("limit", nullable(limit)); + return prepareRedisFuture(commands.xrange(key, range, limit), span); + } + + @Override + public RedisFuture>> xread(StreamOffset... streams) { + Span span = helper.buildSpan("xread"); + span.setTag("streams", Arrays.toString(streams)); + return prepareRedisFuture(commands.xread(streams), span); + } + + @Override + public RedisFuture>> xread(XReadArgs args, StreamOffset... streams) { + Span span = helper.buildSpan("xread"); + span.setTag("streams", Arrays.toString(streams)); + return prepareRedisFuture(commands.xread(args, streams), span); + } + + @Override + public RedisFuture>> xreadgroup(Consumer consumer, + StreamOffset... streams) { + Span span = helper.buildSpan("xreadgroup"); + span.setTag("consumer", nullable(consumer)); + span.setTag("streams", Arrays.toString(streams)); + return prepareRedisFuture(commands.xreadgroup(consumer, streams), span); + } + + @Override + public RedisFuture>> xreadgroup(Consumer consumer, XReadArgs args, + StreamOffset... streams) { + Span span = helper.buildSpan("xreadgroup"); + span.setTag("consumer", nullable(consumer)); + span.setTag("streams", Arrays.toString(streams)); + return prepareRedisFuture(commands.xreadgroup(consumer, args, streams), span); + } + + @Override + public RedisFuture>> xrevrange(K key, Range range) { + Span span = helper.buildSpan("xrevrange", key); + span.setTag("range", nullable(range)); + return prepareRedisFuture(commands.xrevrange(key, range), span); + } + + @Override + public RedisFuture>> xrevrange(K key, Range range, Limit limit) { + Span span = helper.buildSpan("xrevrange", key); + span.setTag("range", nullable(range)); + span.setTag("limit", nullable(limit)); + return prepareRedisFuture(commands.xrevrange(key, range, limit), span); + } + + @Override + public RedisFuture xtrim(K key, long count) { + Span span = helper.buildSpan("xtrim", key); + span.setTag("count", count); + return prepareRedisFuture(commands.xtrim(key, count), span); + } + + @Override + public RedisFuture xtrim(K key, boolean approximateTrimming, long count) { + Span span = helper.buildSpan("xtrim", key); + span.setTag("approximateTrimming", approximateTrimming); + span.setTag("count", count); + return prepareRedisFuture(commands.xtrim(key, approximateTrimming, count), span); + } + @Override public RedisFuture eval(String script, ScriptOutputType type, K... keys) { @@ -2109,6 +2365,14 @@ public RedisFuture clientKill(KillArgs killArgs) { return prepareRedisFuture(commands.clientKill(killArgs), span); } + @Override + public RedisFuture clientUnblock(long id, UnblockType type) { + Span span = helper.buildSpan("clientUnblock"); + span.setTag("id", id); + span.setTag("type", nullable(type)); + return prepareRedisFuture(commands.clientUnblock(id, type), span); + } + @Override public RedisFuture clientPause(long timeout) { Span span = helper.buildSpan("clientPause"); diff --git a/opentracing-redis-lettuce/src/main/java/io/opentracing/contrib/redis/lettuce/TracingRedisCommands.java b/opentracing-redis-lettuce/src/main/java/io/opentracing/contrib/redis/lettuce/TracingRedisCommands.java index 2c0c76b..36aa340 100644 --- a/opentracing-redis-lettuce/src/main/java/io/opentracing/contrib/redis/lettuce/TracingRedisCommands.java +++ b/opentracing-redis-lettuce/src/main/java/io/opentracing/contrib/redis/lettuce/TracingRedisCommands.java @@ -18,6 +18,7 @@ import static io.opentracing.contrib.redis.common.TracingHelper.onError; import io.lettuce.core.BitFieldArgs; +import io.lettuce.core.Consumer; import io.lettuce.core.GeoArgs; import io.lettuce.core.GeoArgs.Unit; import io.lettuce.core.GeoCoordinates; @@ -30,6 +31,7 @@ import io.lettuce.core.MapScanCursor; import io.lettuce.core.MigrateArgs; import io.lettuce.core.Range; +import io.lettuce.core.RestoreArgs; import io.lettuce.core.ScanArgs; import io.lettuce.core.ScanCursor; import io.lettuce.core.ScoredValue; @@ -37,10 +39,16 @@ import io.lettuce.core.ScriptOutputType; import io.lettuce.core.SetArgs; import io.lettuce.core.SortArgs; +import io.lettuce.core.StreamMessage; import io.lettuce.core.StreamScanCursor; import io.lettuce.core.TransactionResult; +import io.lettuce.core.UnblockType; import io.lettuce.core.Value; import io.lettuce.core.ValueScanCursor; +import io.lettuce.core.XAddArgs; +import io.lettuce.core.XClaimArgs; +import io.lettuce.core.XReadArgs; +import io.lettuce.core.XReadArgs.StreamOffset; import io.lettuce.core.ZAddArgs; import io.lettuce.core.ZStoreArgs; import io.lettuce.core.api.StatefulRedisConnection; @@ -806,6 +814,13 @@ public String restore(K key, long ttl, byte[] value) { } } + @Override + public String restore(K key, byte[] value, RestoreArgs args) { + Span span = helper.buildSpan("restore", key); + span.setTag("value", Arrays.toString(value)); + return helper.decorate(span, () -> commands.restore(key, value, args)); + } + @Override public List sort(K key) { Span span = helper.buildSpan("sort", key); @@ -2090,6 +2105,20 @@ public StreamScanCursor sscan( } } + @Override + public KeyValue> bzpopmin(long timeout, K... keys) { + Span span = helper.buildSpan("bzpopmin", keys); + span.setTag("timeout", timeout); + return helper.decorate(span, () -> commands.bzpopmin(timeout, keys)); + } + + @Override + public KeyValue> bzpopmax(long timeout, K... keys) { + Span span = helper.buildSpan("bzpopmax", keys); + span.setTag("timeout", timeout); + return helper.decorate(span, () -> commands.bzpopmax(timeout, keys)); + } + @Override public Long zadd(K key, double score, V member) { Span span = helper.buildSpan("zadd", key); @@ -2258,7 +2287,7 @@ public Long zcount(K key, Range range) { } @Override - public Double zincrby(K key, double amount, K member) { + public Double zincrby(K key, double amount, V member) { Span span = helper.buildSpan("zincrby", key); span.setTag("amount", amount); try { @@ -2327,6 +2356,32 @@ public Long zlexcount(K key, Range range) { } } + @Override + public ScoredValue zpopmin(K key) { + Span span = helper.buildSpan("zpopmin", key); + return helper.decorate(span, () -> commands.zpopmin(key)); + } + + @Override + public List> zpopmin(K key, long count) { + Span span = helper.buildSpan("zpopmin", key); + span.setTag("count", count); + return helper.decorate(span, () -> commands.zpopmin(key, count)); + } + + @Override + public ScoredValue zpopmax(K key) { + Span span = helper.buildSpan("zpopmax", key); + return helper.decorate(span, () -> commands.zpopmax(key)); + } + + @Override + public List> zpopmax(K key, long count) { + Span span = helper.buildSpan("zpopmax", key); + span.setTag("count", count); + return helper.decorate(span, () -> commands.zpopmax(key, count)); + } + @Override public List zrange(K key, long start, long stop) { Span span = helper.buildSpan("zrange", key); @@ -3652,6 +3707,205 @@ public Long zunionstore(K destination, ZStoreArgs storeArgs, K... keys) { } } + @Override + public Long xack(K key, K group, String... messageIds) { + Span span = helper.buildSpan("xack", key); + span.setTag("group", nullable(group)); + span.setTag("messageIds", Arrays.toString(messageIds)); + return helper.decorate(span, () -> commands.xack(key, group, messageIds)); + } + + @Override + public String xadd(K key, Map body) { + Span span = helper.buildSpan("xadd", key); + span.setTag("body", TracingHelper.mapToString(body)); + return helper.decorate(span, () -> commands.xadd(key, body)); + } + + @Override + public String xadd(K key, XAddArgs args, Map body) { + Span span = helper.buildSpan("xadd", key); + span.setTag("body", TracingHelper.mapToString(body)); + return helper.decorate(span, () -> commands.xadd(key, args, body)); + } + + @Override + public String xadd(K key, Object... keysAndValues) { + Span span = helper.buildSpan("xadd", key); + span.setTag("keysAndValues", Arrays.toString(keysAndValues)); + return helper.decorate(span, () -> commands.xadd(key, keysAndValues)); + } + + @Override + public String xadd(K key, XAddArgs args, Object... keysAndValues) { + Span span = helper.buildSpan("xadd", key); + span.setTag("keysAndValues", Arrays.toString(keysAndValues)); + return helper.decorate(span, () -> commands.xadd(key, args, keysAndValues)); + } + + @Override + public List> xclaim(K key, Consumer consumer, long minIdleTime, + String... messageIds) { + Span span = helper.buildSpan("xclaim", key); + span.setTag("minIdleTime", minIdleTime); + span.setTag("consumer", nullable(consumer)); + span.setTag("messageIds", Arrays.toString(messageIds)); + return helper.decorate(span, () -> commands.xclaim(key, consumer, minIdleTime, messageIds)); + } + + @Override + public List> xclaim(K key, Consumer consumer, XClaimArgs args, + String... messageIds) { + Span span = helper.buildSpan("xclaim", key); + span.setTag("consumer", nullable(consumer)); + span.setTag("messageIds", Arrays.toString(messageIds)); + return helper.decorate(span, () -> commands.xclaim(key, consumer, args, messageIds)); + } + + @Override + public Long xdel(K key, String... messageIds) { + Span span = helper.buildSpan("xdel", key); + span.setTag("messageIds", Arrays.toString(messageIds)); + return helper.decorate(span, () -> commands.xdel(key, messageIds)); + } + + @Override + public String xgroupCreate(StreamOffset streamOffset, K group) { + Span span = helper.buildSpan("xgroupCreate"); + span.setTag("streamOffset", nullable(streamOffset)); + span.setTag("group", nullable(group)); + return helper.decorate(span, () -> commands.xgroupCreate(streamOffset, group)); + } + + @Override + public Boolean xgroupDelconsumer(K key, Consumer consumer) { + Span span = helper.buildSpan("xgroupDelconsumer", key); + span.setTag("consumer", nullable(consumer)); + return helper.decorate(span, () -> commands.xgroupDelconsumer(key, consumer)); + } + + @Override + public Boolean xgroupDestroy(K key, K group) { + Span span = helper.buildSpan("xgroupDestroy", key); + span.setTag("group", nullable(group)); + return helper.decorate(span, () -> commands.xgroupDestroy(key, group)); + } + + @Override + public String xgroupSetid(StreamOffset streamOffset, K group) { + Span span = helper.buildSpan("xgroupSetid"); + span.setTag("streamOffset", nullable(streamOffset)); + span.setTag("group", nullable(group)); + return helper.decorate(span, () -> commands.xgroupSetid(streamOffset, group)); + } + + @Override + public Long xlen(K key) { + Span span = helper.buildSpan("xlen", key); + return helper.decorate(span, () -> commands.xlen(key)); + } + + @Override + public List xpending(K key, K group) { + Span span = helper.buildSpan("xpending", key); + span.setTag("group", nullable(group)); + return helper.decorate(span, () -> commands.xpending(key, group)); + } + + @Override + public List xpending(K key, K group, Range range, Limit limit) { + Span span = helper.buildSpan("xpending", key); + span.setTag("group", nullable(group)); + span.setTag("range", nullable(range)); + span.setTag("limit", nullable(limit)); + return helper.decorate(span, () -> commands.xpending(key, group, range, limit)); + } + + @Override + public List xpending(K key, Consumer consumer, Range range, Limit limit) { + Span span = helper.buildSpan("xpending", key); + span.setTag("consumer", nullable(consumer)); + span.setTag("range", nullable(range)); + span.setTag("limit", nullable(limit)); + return helper.decorate(span, () -> commands.xpending(key, consumer, range, limit)); + } + + @Override + public List> xrange(K key, Range range) { + Span span = helper.buildSpan("xrange", key); + span.setTag("range", nullable(range)); + return helper.decorate(span, () -> commands.xrange(key, range)); + } + + @Override + public List> xrange(K key, Range range, Limit limit) { + Span span = helper.buildSpan("xrange", key); + span.setTag("range", nullable(range)); + span.setTag("limit", nullable(limit)); + return helper.decorate(span, () -> commands.xrange(key, range, limit)); + } + + @Override + public List> xread(StreamOffset... streams) { + Span span = helper.buildSpan("xread"); + span.setTag("streams", Arrays.toString(streams)); + return helper.decorate(span, () -> commands.xread(streams)); + } + + @Override + public List> xread(XReadArgs args, StreamOffset... streams) { + Span span = helper.buildSpan("xread"); + span.setTag("streams", Arrays.toString(streams)); + return helper.decorate(span, () -> commands.xread(args, streams)); + } + + @Override + public List> xreadgroup(Consumer consumer, StreamOffset... streams) { + Span span = helper.buildSpan("xreadgroup"); + span.setTag("consumer", nullable(consumer)); + span.setTag("streams", Arrays.toString(streams)); + return helper.decorate(span, () -> commands.xreadgroup(consumer, streams)); + } + + @Override + public List> xreadgroup(Consumer consumer, XReadArgs args, + StreamOffset... streams) { + Span span = helper.buildSpan("xreadgroup"); + span.setTag("consumer", nullable(consumer)); + span.setTag("streams", Arrays.toString(streams)); + return helper.decorate(span, () -> commands.xreadgroup(consumer, args, streams)); + } + + @Override + public List> xrevrange(K key, Range range) { + Span span = helper.buildSpan("xrevrange", key); + span.setTag("range", nullable(range)); + return helper.decorate(span, () -> commands.xrevrange(key, range)); + } + + @Override + public List> xrevrange(K key, Range range, Limit limit) { + Span span = helper.buildSpan("xrevrange", key); + span.setTag("range", nullable(range)); + span.setTag("limit", nullable(limit)); + return helper.decorate(span, () -> commands.xrevrange(key, range, limit)); + } + + @Override + public Long xtrim(K key, long count) { + Span span = helper.buildSpan("xtrim", key); + span.setTag("count", count); + return helper.decorate(span, () -> commands.xtrim(key, count)); + } + + @Override + public Long xtrim(K key, boolean approximateTrimming, long count) { + Span span = helper.buildSpan("xtrim", key); + span.setTag("approximateTrimming", approximateTrimming); + span.setTag("count", count); + return helper.decorate(span, () -> commands.xtrim(key, approximateTrimming, count)); + } + @Override public T eval(String script, ScriptOutputType type, K... keys) { Span span = helper.buildSpan("eval", keys); @@ -3848,6 +4102,14 @@ public Long clientKill(KillArgs killArgs) { } } + @Override + public Long clientUnblock(long id, UnblockType type) { + Span span = helper.buildSpan("clientUnblock"); + span.setTag("id", id); + span.setTag("type", nullable(type)); + return helper.decorate(span, () -> commands.clientUnblock(id, type)); + } + @Override public String clientPause(long timeout) { Span span = helper.buildSpan("clientPause"); diff --git a/opentracing-redis-lettuce/src/main/java/io/opentracing/contrib/redis/lettuce/TracingStatefulRedisConnection.java b/opentracing-redis-lettuce/src/main/java/io/opentracing/contrib/redis/lettuce/TracingStatefulRedisConnection.java index cdc7a1e..df795ed 100644 --- a/opentracing-redis-lettuce/src/main/java/io/opentracing/contrib/redis/lettuce/TracingStatefulRedisConnection.java +++ b/opentracing-redis-lettuce/src/main/java/io/opentracing/contrib/redis/lettuce/TracingStatefulRedisConnection.java @@ -19,9 +19,11 @@ import io.lettuce.core.api.reactive.RedisReactiveCommands; import io.lettuce.core.api.sync.RedisCommands; import io.lettuce.core.protocol.RedisCommand; +import io.lettuce.core.resource.ClientResources; import io.opentracing.contrib.redis.common.TracingConfiguration; import java.time.Duration; import java.util.Collection; +import java.util.concurrent.CompletableFuture; import java.util.concurrent.TimeUnit; public class TracingStatefulRedisConnection implements StatefulRedisConnection { @@ -92,6 +94,11 @@ public void close() { connection.close(); } + @Override + public CompletableFuture closeAsync() { + return connection.closeAsync(); + } + @Override public boolean isOpen() { return connection.isOpen(); @@ -102,6 +109,11 @@ public ClientOptions getOptions() { return connection.getOptions(); } + @Override + public ClientResources getResources() { + return connection.getResources(); + } + @Override public void reset() { connection.reset();