/* * Copyright 2017-2020 The OpenTracing Authors * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except * in compliance with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express * or implied. See the License for the specific language governing permissions and limitations under * the License. */ package io.opentracing.contrib.redis.spring.data2.connection; import io.opentracing.contrib.redis.common.RedisCommand; import io.opentracing.contrib.redis.common.TracingConfiguration; import io.opentracing.contrib.redis.common.TracingHelper; import java.time.Duration; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Properties; import java.util.Set; import java.util.concurrent.TimeUnit; import org.springframework.dao.DataAccessException; import org.springframework.data.geo.Circle; import org.springframework.data.geo.Distance; import org.springframework.data.geo.GeoResults; import org.springframework.data.geo.Metric; import org.springframework.data.geo.Point; import org.springframework.data.redis.connection.BitFieldSubCommands; import org.springframework.data.redis.connection.DataType; import org.springframework.data.redis.connection.MessageListener; import org.springframework.data.redis.connection.RedisConnection; import org.springframework.data.redis.connection.RedisGeoCommands; import org.springframework.data.redis.connection.RedisHashCommands; import org.springframework.data.redis.connection.RedisHyperLogLogCommands; import org.springframework.data.redis.connection.RedisKeyCommands; import org.springframework.data.redis.connection.RedisListCommands; import org.springframework.data.redis.connection.RedisNode; import org.springframework.data.redis.connection.RedisPipelineException; import org.springframework.data.redis.connection.RedisScriptingCommands; import org.springframework.data.redis.connection.RedisSentinelConnection; import org.springframework.data.redis.connection.RedisServerCommands; import org.springframework.data.redis.connection.RedisSetCommands; import org.springframework.data.redis.connection.RedisStringCommands; import org.springframework.data.redis.connection.RedisZSetCommands; import org.springframework.data.redis.connection.ReturnType; import org.springframework.data.redis.connection.SortParameters; import org.springframework.data.redis.connection.Subscription; import org.springframework.data.redis.connection.ValueEncoding; import org.springframework.data.redis.connection.stream.ByteRecord; import org.springframework.data.redis.connection.stream.Consumer; import org.springframework.data.redis.connection.stream.MapRecord; import org.springframework.data.redis.connection.stream.ReadOffset; import org.springframework.data.redis.connection.stream.RecordId; import org.springframework.data.redis.connection.stream.StreamOffset; import org.springframework.data.redis.connection.stream.StreamReadOptions; import org.springframework.data.redis.core.Cursor; import org.springframework.data.redis.core.ScanOptions; import org.springframework.data.redis.core.types.Expiration; import org.springframework.data.redis.core.types.RedisClientInfo; /** * OpenTracing instrumentation of a {@link RedisConnection}. * * @author Daniel del Castillo */ public class TracingRedisConnection implements RedisConnection { private final RedisConnection connection; private final TracingConfiguration tracingConfiguration; private final TracingHelper helper; public TracingRedisConnection(RedisConnection connection, TracingConfiguration tracingConfiguration) { this.connection = connection; this.tracingConfiguration = tracingConfiguration; this.helper = new TracingHelper(tracingConfiguration); } @Override public RedisGeoCommands geoCommands() { return connection.geoCommands(); } @Override public RedisHashCommands hashCommands() { return connection.hashCommands(); } @Override public RedisHyperLogLogCommands hyperLogLogCommands() { return connection.hyperLogLogCommands(); } @Override public RedisKeyCommands keyCommands() { return connection.keyCommands(); } @Override public RedisListCommands listCommands() { return connection.listCommands(); } @Override public RedisSetCommands setCommands() { return connection.setCommands(); } @Override public RedisScriptingCommands scriptingCommands() { return connection.scriptingCommands(); } @Override public RedisServerCommands serverCommands() { return connection.serverCommands(); } @Override public RedisStringCommands stringCommands() { return connection.stringCommands(); } @Override public RedisZSetCommands zSetCommands() { return connection.zSetCommands(); } @Override public void close() throws DataAccessException { connection.close(); } @Override public boolean isClosed() { return connection.isClosed(); } @Override public Object getNativeConnection() { return connection.getNativeConnection(); } @Override public boolean isQueueing() { return connection.isQueueing(); } @Override public boolean isPipelined() { return connection.isPipelined(); } @Override public void openPipeline() { connection.openPipeline(); } @Override public List<Object> closePipeline() throws RedisPipelineException { return connection.closePipeline(); } @Override public boolean isSubscribed() { return connection.isSubscribed(); } @Override public Subscription getSubscription() { return connection.getSubscription(); } @Override public RedisSentinelConnection getSentinelConnection() { return new TracingRedisSentinelConnection(connection.getSentinelConnection(), tracingConfiguration); } @Override public Object execute(String command, byte[]... args) { return helper.doInScope(command, () -> connection.execute(command, args)); } @Override public Boolean exists(byte[] key) { return helper.doInScope(RedisCommand.EXISTS, key, () -> connection.exists(key)); } @Override public Long exists(byte[]... keys) { return helper.doInScope(RedisCommand.EXISTS, keys, () -> connection.exists(keys)); } @Override public Long del(byte[]... keys) { return helper.doInScope(RedisCommand.DEL, keys, () -> connection.del(keys)); } @Override public Long unlink(byte[]... keys) { return helper.doInScope(RedisCommand.UNLINK, keys, () -> connection.unlink(keys)); } @Override public DataType type(byte[] key) { return helper.doInScope(RedisCommand.TYPE, key, () -> connection.type(key)); } @Override public Long touch(byte[]... keys) { return helper.doInScope(RedisCommand.TOUCH, keys, () -> connection.touch(keys)); } @Override public Set<byte[]> keys(byte[] pattern) { return helper.doInScope(RedisCommand.KEYS, () -> connection.keys(pattern)); } @Override public Cursor<byte[]> scan(ScanOptions options) { return helper.doInScope(RedisCommand.SCAN, () -> connection.scan(options)); } @Override public byte[] randomKey() { return helper.doInScope(RedisCommand.RANDOMKEY, () -> connection.randomKey()); } @Override public void rename(byte[] sourceKey, byte[] targetKey) { helper.doInScope(RedisCommand.RENAME, sourceKey, () -> connection.rename(sourceKey, targetKey)); } @Override public Boolean renameNX(byte[] sourceKey, byte[] targetKey) { return helper.doInScope(RedisCommand.RENAMENX, sourceKey, () -> connection.renameNX(sourceKey, targetKey)); } @Override public Boolean expire(byte[] key, long seconds) { return helper.doInScope(RedisCommand.EXPIRE, key, () -> connection.expire(key, seconds)); } @Override public Boolean pExpire(byte[] key, long millis) { return helper.doInScope(RedisCommand.PEXPIRE, key, () -> connection.pExpire(key, millis)); } @Override public Boolean expireAt(byte[] key, long unixTime) { return helper.doInScope(RedisCommand.EXPIREAT, key, () -> connection.expireAt(key, unixTime)); } @Override public Boolean pExpireAt(byte[] key, long unixTimeInMillis) { return helper .doInScope(RedisCommand.PEXPIREAT, key, () -> connection.pExpireAt(key, unixTimeInMillis)); } @Override public Boolean persist(byte[] key) { return helper.doInScope(RedisCommand.PERSIST, key, () -> connection.persist(key)); } @Override public Boolean move(byte[] key, int dbIndex) { return helper.doInScope(RedisCommand.MOVE, key, () -> connection.move(key, dbIndex)); } @Override public Long ttl(byte[] key) { return helper.doInScope(RedisCommand.TTL, key, () -> connection.ttl(key)); } @Override public Long ttl(byte[] key, TimeUnit timeUnit) { return helper.doInScope(RedisCommand.TTL, key, () -> connection.ttl(key, timeUnit)); } @Override public Long pTtl(byte[] key) { return helper.doInScope(RedisCommand.PTTL, key, () -> connection.pTtl(key)); } @Override public Long pTtl(byte[] key, TimeUnit timeUnit) { return helper.doInScope(RedisCommand.PTTL, key, () -> connection.pTtl(key, timeUnit)); } @Override public List<byte[]> sort(byte[] key, SortParameters params) { return helper.doInScope(RedisCommand.SORT, key, () -> connection.sort(key, params)); } @Override public Long sort(byte[] key, SortParameters params, byte[] storeKey) { return helper.doInScope(RedisCommand.SORT, key, () -> connection.sort(key, params, storeKey)); } @Override public byte[] dump(byte[] key) { return helper.doInScope(RedisCommand.DUMP, key, () -> connection.dump(key)); } @Override public void restore(byte[] key, long ttlInMillis, byte[] serializedValue) { helper.doInScope(RedisCommand.RESTORE, key, () -> connection.restore(key, ttlInMillis, serializedValue)); } @Override public void restore(byte[] key, long ttlInMillis, byte[] serializedValue, boolean replace) { helper.doInScope(RedisCommand.RESTORE, key, () -> connection.restore(key, ttlInMillis, serializedValue, replace)); } @Override public ValueEncoding encodingOf(byte[] key) { return helper.doInScope(RedisCommand.ENCODING, key, () -> connection.encodingOf(key)); } @Override public Duration idletime(byte[] key) { return helper.doInScope(RedisCommand.IDLETIME, key, () -> connection.idletime(key)); } @Override public Long refcount(byte[] key) { return helper.doInScope(RedisCommand.REFCOUNT, key, () -> connection.refcount(key)); } @Override public byte[] get(byte[] key) { return helper.doInScope(RedisCommand.GET, key, () -> connection.get(key)); } @Override public byte[] getSet(byte[] key, byte[] value) { return helper.doInScope(RedisCommand.GETSET, key, () -> connection.getSet(key, value)); } @Override public List<byte[]> mGet(byte[]... keys) { return helper.doInScope(RedisCommand.MGET, keys, () -> connection.mGet(keys)); } @Override public Boolean set(byte[] key, byte[] value) { return helper.doInScope(RedisCommand.SET, key, () -> connection.set(key, value)); } @Override public Boolean set(byte[] key, byte[] value, Expiration expiration, SetOption option) { return helper .doInScope(RedisCommand.SET, key, () -> connection.set(key, value, expiration, option)); } @Override public Boolean setNX(byte[] key, byte[] value) { return helper.doInScope(RedisCommand.SETNX, key, () -> connection.setNX(key, value)); } @Override public Boolean setEx(byte[] key, long seconds, byte[] value) { return helper.doInScope(RedisCommand.SETEX, key, () -> connection.setEx(key, seconds, value)); } @Override public Boolean pSetEx(byte[] key, long milliseconds, byte[] value) { return helper .doInScope(RedisCommand.PSETEX, key, () -> connection.pSetEx(key, milliseconds, value)); } @Override public Boolean mSet(Map<byte[], byte[]> tuple) { return helper.doInScope(RedisCommand.MSET, () -> connection.mSet(tuple)); } @Override public Boolean mSetNX(Map<byte[], byte[]> tuple) { return helper.doInScope(RedisCommand.MSETNX, () -> connection.mSetNX(tuple)); } @Override public Long incr(byte[] key) { return helper.doInScope(RedisCommand.INCR, key, () -> connection.incr(key)); } @Override public Long incrBy(byte[] key, long value) { return helper.doInScope(RedisCommand.INCRBY, key, () -> connection.incrBy(key, value)); } @Override public Double incrBy(byte[] key, double value) { return helper.doInScope(RedisCommand.INCRBY, key, () -> connection.incrBy(key, value)); } @Override public Long decr(byte[] key) { return helper.doInScope(RedisCommand.DECR, key, () -> connection.decr(key)); } @Override public Long decrBy(byte[] key, long value) { return helper.doInScope(RedisCommand.DECRBY, key, () -> connection.decrBy(key, value)); } @Override public Long append(byte[] key, byte[] value) { return helper.doInScope(RedisCommand.APPEND, key, () -> connection.append(key, value)); } @Override public byte[] getRange(byte[] key, long begin, long end) { return helper.doInScope(RedisCommand.GETRANGE, key, () -> connection.getRange(key, begin, end)); } @Override public void setRange(byte[] key, byte[] value, long offset) { helper.doInScope(RedisCommand.SETRANGE, key, () -> connection.setRange(key, value, offset)); } @Override public Boolean getBit(byte[] key, long offset) { return helper.doInScope(RedisCommand.GETBIT, key, () -> connection.getBit(key, offset)); } @Override public Boolean setBit(byte[] key, long offset, boolean value) { return helper.doInScope(RedisCommand.SETBIT, key, () -> connection.setBit(key, offset, value)); } @Override public Long bitCount(byte[] key) { return helper.doInScope(RedisCommand.BITCOUNT, key, () -> connection.bitCount(key)); } @Override public Long bitCount(byte[] key, long begin, long end) { return helper.doInScope(RedisCommand.BITCOUNT, key, () -> connection.bitCount(key, begin, end)); } @Override public List<Long> bitField(byte[] key, BitFieldSubCommands subCommands) { return helper .doInScope(RedisCommand.BITFIELD, key, () -> connection.bitField(key, subCommands)); } @Override public Long bitOp(BitOperation op, byte[] destination, byte[]... keys) { return helper .doInScope(RedisCommand.BITOP, keys, () -> connection.bitOp(op, destination, keys)); } @Override public Long bitPos(byte[] key, boolean bit, org.springframework.data.domain.Range<Long> range) { return helper.doInScope(RedisCommand.BITPOS, key, () -> connection.bitPos(key, bit, range)); } @Override public Long strLen(byte[] key) { return helper.doInScope(RedisCommand.STRLEN, key, () -> connection.strLen(key)); } @Override public Long rPush(byte[] key, byte[]... values) { return helper.doInScope(RedisCommand.RPUSH, key, () -> connection.rPush(key, values)); } @Override public Long lPush(byte[] key, byte[]... values) { return helper.doInScope(RedisCommand.LPUSH, key, () -> connection.lPush(key, values)); } @Override public Long rPushX(byte[] key, byte[] value) { return helper.doInScope(RedisCommand.RPUSHX, key, () -> connection.rPushX(key, value)); } @Override public Long lPushX(byte[] key, byte[] value) { return helper.doInScope(RedisCommand.LPUSHX, key, () -> connection.lPushX(key, value)); } @Override public Long lLen(byte[] key) { return helper.doInScope(RedisCommand.LLEN, key, () -> connection.lLen(key)); } @Override public List<byte[]> lRange(byte[] key, long start, long end) { return helper.doInScope(RedisCommand.LRANGE, key, () -> connection.lRange(key, start, end)); } @Override public void lTrim(byte[] key, long start, long end) { helper.doInScope(RedisCommand.LTRIM, key, () -> connection.lTrim(key, start, end)); } @Override public byte[] lIndex(byte[] key, long index) { return helper.doInScope(RedisCommand.LINDEX, key, () -> connection.lIndex(key, index)); } @Override public Long lInsert(byte[] key, Position where, byte[] pivot, byte[] value) { return helper .doInScope(RedisCommand.LINSERT, key, () -> connection.lInsert(key, where, pivot, value)); } @Override public void lSet(byte[] key, long index, byte[] value) { helper.doInScope(RedisCommand.LSET, key, () -> connection.lSet(key, index, value)); } @Override public Long lRem(byte[] key, long count, byte[] value) { return helper.doInScope(RedisCommand.LREM, key, () -> connection.lRem(key, count, value)); } @Override public byte[] lPop(byte[] key) { return helper.doInScope(RedisCommand.LPOP, key, () -> connection.lPop(key)); } @Override public byte[] rPop(byte[] key) { return helper.doInScope(RedisCommand.RPOP, key, () -> connection.rPop(key)); } @Override public List<byte[]> bLPop(int timeout, byte[]... keys) { return helper.doInScope(RedisCommand.BLPOP, keys, () -> connection.bLPop(timeout, keys)); } @Override public List<byte[]> bRPop(int timeout, byte[]... keys) { return helper.doInScope(RedisCommand.BRPOP, keys, () -> connection.bRPop(timeout, keys)); } @Override public byte[] rPopLPush(byte[] srcKey, byte[] dstKey) { return helper .doInScope(RedisCommand.RPOPLPUSH, srcKey, () -> connection.rPopLPush(srcKey, dstKey)); } @Override public byte[] bRPopLPush(int timeout, byte[] srcKey, byte[] dstKey) { return helper.doInScope(RedisCommand.BRPOPLPUSH, srcKey, () -> connection.bRPopLPush(timeout, srcKey, dstKey)); } @Override public Long sAdd(byte[] key, byte[]... values) { return helper.doInScope(RedisCommand.SADD, key, () -> connection.sAdd(key, values)); } @Override public Long sRem(byte[] key, byte[]... values) { return helper.doInScope(RedisCommand.SREM, key, () -> connection.sRem(key, values)); } @Override public byte[] sPop(byte[] key) { return helper.doInScope(RedisCommand.SPOP, key, () -> connection.sPop(key)); } @Override public List<byte[]> sPop(byte[] key, long count) { return helper.doInScope(RedisCommand.SPOP, key, () -> connection.sPop(key, count)); } @Override public Boolean sMove(byte[] srcKey, byte[] destKey, byte[] value) { return helper .doInScope(RedisCommand.SMOVE, srcKey, () -> connection.sMove(srcKey, destKey, value)); } @Override public Long sCard(byte[] key) { return helper.doInScope(RedisCommand.SCARD, key, () -> connection.sCard(key)); } @Override public Boolean sIsMember(byte[] key, byte[] value) { return helper.doInScope(RedisCommand.SISMEMBER, key, () -> connection.sIsMember(key, value)); } @Override public Set<byte[]> sInter(byte[]... keys) { return helper.doInScope(RedisCommand.SINTER, keys, () -> connection.sInter(keys)); } @Override public Long sInterStore(byte[] destKey, byte[]... keys) { return helper .doInScope(RedisCommand.SINTERSTORE, keys, () -> connection.sInterStore(destKey, keys)); } @Override public Set<byte[]> sUnion(byte[]... keys) { return helper.doInScope(RedisCommand.SUNION, keys, () -> connection.sUnion(keys)); } @Override public Long sUnionStore(byte[] destKey, byte[]... keys) { return helper .doInScope(RedisCommand.SUNIONSTORE, keys, () -> connection.sUnionStore(destKey, keys)); } @Override public Set<byte[]> sDiff(byte[]... keys) { return helper.doInScope(RedisCommand.SDIFF, keys, () -> connection.sDiff(keys)); } @Override public Long sDiffStore(byte[] destKey, byte[]... keys) { return helper .doInScope(RedisCommand.SDIFFSTORE, keys, () -> connection.sDiffStore(destKey, keys)); } @Override public Set<byte[]> sMembers(byte[] key) { return helper.doInScope(RedisCommand.SMEMBERS, key, () -> connection.sMembers(key)); } @Override public byte[] sRandMember(byte[] key) { return helper.doInScope(RedisCommand.SRANDMEMBER, key, () -> connection.sRandMember(key)); } @Override public List<byte[]> sRandMember(byte[] key, long count) { return helper .doInScope(RedisCommand.SRANDMEMBER, key, () -> connection.sRandMember(key, count)); } @Override public Cursor<byte[]> sScan(byte[] key, ScanOptions options) { return helper.doInScope(RedisCommand.SSCAN, key, () -> connection.sScan(key, options)); } @Override public Boolean zAdd(byte[] key, double score, byte[] value) { return helper.doInScope(RedisCommand.ZADD, key, () -> connection.zAdd(key, score, value)); } @Override public Long zAdd(byte[] key, Set<Tuple> tuples) { return helper.doInScope(RedisCommand.ZADD, key, () -> connection.zAdd(key, tuples)); } @Override public Long zRem(byte[] key, byte[]... values) { return helper.doInScope(RedisCommand.ZREM, key, () -> connection.zRem(key, values)); } @Override public Double zIncrBy(byte[] key, double increment, byte[] value) { return helper .doInScope(RedisCommand.ZINCRBY, key, () -> connection.zIncrBy(key, increment, value)); } @Override public Long zRank(byte[] key, byte[] value) { return helper.doInScope(RedisCommand.ZRANK, key, () -> connection.zRank(key, value)); } @Override public Long zRevRank(byte[] key, byte[] value) { return helper.doInScope(RedisCommand.ZREVRANK, key, () -> connection.zRevRank(key, value)); } @Override public Set<byte[]> zRange(byte[] key, long start, long end) { return helper.doInScope(RedisCommand.ZRANGE, key, () -> connection.zRange(key, start, end)); } @Override public Set<byte[]> zRevRange(byte[] key, long start, long end) { return helper .doInScope(RedisCommand.ZREVRANGE, key, () -> connection.zRevRange(key, start, end)); } @Override public Set<Tuple> zRevRangeWithScores(byte[] key, long start, long end) { return helper.doInScope(RedisCommand.ZREVRANGE_WITHSCORES, key, () -> connection.zRevRangeWithScores(key, start, end)); } @Override public Set<Tuple> zRangeWithScores(byte[] key, long start, long end) { return helper.doInScope(RedisCommand.ZRANGE_WITHSCORES, key, () -> connection.zRangeWithScores(key, start, end)); } @Override public Set<byte[]> zRangeByScore(byte[] key, double min, double max) { return helper .doInScope(RedisCommand.ZRANGEBYSCORE, key, () -> connection.zRangeByScore(key, min, max)); } @Override public Set<byte[]> zRangeByScore(byte[] key, double min, double max, long offset, long count) { return helper.doInScope(RedisCommand.ZRANGEBYSCORE, key, () -> connection.zRangeByScore(key, min, max, offset, count)); } @Override public Set<byte[]> zRangeByScore(byte[] key, String min, String max) { return helper .doInScope(RedisCommand.ZRANGEBYSCORE, key, () -> connection.zRangeByScore(key, min, max)); } @Override public Set<byte[]> zRangeByScore(byte[] key, Range range) { return helper .doInScope(RedisCommand.ZRANGEBYSCORE, key, () -> connection.zRangeByScore(key, range)); } @Override public Set<byte[]> zRangeByScore(byte[] key, String min, String max, long offset, long count) { return helper.doInScope(RedisCommand.ZRANGEBYSCORE, key, () -> connection.zRangeByScore(key, min, max, offset, count)); } @Override public Set<byte[]> zRangeByScore(byte[] key, Range range, Limit limit) { return helper.doInScope(RedisCommand.ZRANGEBYSCORE, key, () -> connection.zRangeByScore(key, range, limit)); } @Override public Set<Tuple> zRangeByScoreWithScores(byte[] key, Range range) { return helper.doInScope(RedisCommand.ZRANGEBYSCORE_WITHSCORES, key, () -> connection.zRangeByScoreWithScores(key, range)); } @Override public Set<Tuple> zRangeByScoreWithScores(byte[] key, double min, double max) { return helper.doInScope(RedisCommand.ZRANGEBYSCORE_WITHSCORES, key, () -> connection.zRangeByScoreWithScores(key, min, max)); } @Override public Set<Tuple> zRangeByScoreWithScores(byte[] key, double min, double max, long offset, long count) { return helper.doInScope(RedisCommand.ZRANGEBYSCORE_WITHSCORES, key, () -> connection.zRangeByScoreWithScores(key, min, max, offset, count)); } @Override public Set<Tuple> zRangeByScoreWithScores(byte[] key, Range range, Limit limit) { return helper.doInScope(RedisCommand.ZRANGEBYSCORE_WITHSCORES, key, () -> connection.zRangeByScoreWithScores(key, range, limit)); } @Override public Set<byte[]> zRevRangeByScore(byte[] key, double min, double max) { return helper.doInScope(RedisCommand.ZREVRANGEBYSCORE, key, () -> connection.zRevRangeByScore(key, min, max)); } @Override public Set<byte[]> zRevRangeByScore(byte[] key, Range range) { return helper.doInScope(RedisCommand.ZREVRANGEBYSCORE, key, () -> connection.zRevRangeByScore(key, range)); } @Override public Set<byte[]> zRevRangeByScore(byte[] key, double min, double max, long offset, long count) { return helper.doInScope(RedisCommand.ZREVRANGEBYSCORE, key, () -> connection.zRevRangeByScore(key, min, max, offset, count)); } @Override public Set<byte[]> zRevRangeByScore(byte[] key, Range range, Limit limit) { return helper.doInScope(RedisCommand.ZREVRANGEBYSCORE, key, () -> connection.zRevRangeByScore(key, range, limit)); } @Override public Set<Tuple> zRevRangeByScoreWithScores(byte[] key, double min, double max) { return helper.doInScope(RedisCommand.ZREVRANGEBYSCORE_WITHSCORES, key, () -> connection.zRevRangeByScoreWithScores(key, min, max)); } @Override public Set<Tuple> zRevRangeByScoreWithScores(byte[] key, double min, double max, long offset, long count) { return helper.doInScope(RedisCommand.ZREVRANGEBYSCORE_WITHSCORES, key, () -> connection.zRevRangeByScoreWithScores(key, min, max, offset, count)); } @Override public Set<Tuple> zRevRangeByScoreWithScores(byte[] key, Range range) { return helper.doInScope(RedisCommand.ZREVRANGEBYSCORE_WITHSCORES, key, () -> connection.zRevRangeByScoreWithScores(key, range)); } @Override public Set<Tuple> zRevRangeByScoreWithScores(byte[] key, Range range, Limit limit) { return helper.doInScope(RedisCommand.ZREVRANGEBYSCORE_WITHSCORES, key, () -> connection.zRevRangeByScoreWithScores(key, range, limit)); } @Override public Long zCount(byte[] key, double min, double max) { return helper.doInScope(RedisCommand.ZCOUNT, key, () -> connection.zCount(key, min, max)); } @Override public Long zCount(byte[] key, Range range) { return helper.doInScope(RedisCommand.ZCOUNT, key, () -> connection.zCount(key, range)); } @Override public Long zCard(byte[] key) { return helper.doInScope(RedisCommand.ZCARD, key, () -> connection.zCard(key)); } @Override public Double zScore(byte[] key, byte[] value) { return helper.doInScope(RedisCommand.ZSCORE, key, () -> connection.zScore(key, value)); } @Override public Long zRemRange(byte[] key, long start, long end) { return helper .doInScope(RedisCommand.ZREMRANGE, key, () -> connection.zRemRange(key, start, end)); } @Override public Long zRemRangeByScore(byte[] key, double min, double max) { return helper.doInScope(RedisCommand.ZREMRANGEBYSCORE, key, () -> connection.zRemRangeByScore(key, min, max)); } @Override public Long zRemRangeByScore(byte[] key, Range range) { return helper.doInScope(RedisCommand.ZREMRANGEBYSCORE, key, () -> connection.zRemRangeByScore(key, range)); } @Override public Long zUnionStore(byte[] destKey, byte[]... sets) { return helper.doInScope(RedisCommand.ZUNIONSTORE, () -> connection.zUnionStore(destKey, sets)); } @Override public Long zUnionStore(byte[] destKey, Aggregate aggregate, int[] weights, byte[]... sets) { return helper.doInScope(RedisCommand.ZUNIONSTORE, destKey, () -> connection.zUnionStore(destKey, aggregate, weights, sets)); } @Override public Long zUnionStore(byte[] destKey, Aggregate aggregate, Weights weights, byte[]... sets) { return helper.doInScope(RedisCommand.ZUNIONSTORE, destKey, () -> connection.zUnionStore(destKey, aggregate, weights, sets)); } @Override public Long zInterStore(byte[] destKey, byte[]... sets) { return helper .doInScope(RedisCommand.ZINTERSTORE, destKey, () -> connection.zInterStore(destKey, sets)); } @Override public Long zInterStore(byte[] destKey, Aggregate aggregate, int[] weights, byte[]... sets) { return helper.doInScope(RedisCommand.ZINTERSTORE, destKey, () -> connection.zInterStore(destKey, aggregate, weights, sets)); } @Override public Long zInterStore(byte[] destKey, Aggregate aggregate, Weights weights, byte[]... sets) { return helper.doInScope(RedisCommand.ZINTERSTORE, destKey, () -> connection.zInterStore(destKey, aggregate, weights, sets)); } @Override public Cursor<Tuple> zScan(byte[] key, ScanOptions options) { return helper.doInScope(RedisCommand.ZSCAN, key, () -> connection.zScan(key, options)); } @Override public Set<byte[]> zRangeByLex(byte[] key) { return helper.doInScope(RedisCommand.ZRANGEBYLEX, key, () -> connection.zRangeByLex(key)); } @Override public Set<byte[]> zRangeByLex(byte[] key, Range range) { return helper .doInScope(RedisCommand.ZRANGEBYLEX, key, () -> connection.zRangeByLex(key, range)); } @Override public Set<byte[]> zRangeByLex(byte[] key, Range range, Limit limit) { return helper .doInScope(RedisCommand.ZRANGEBYLEX, key, () -> connection.zRangeByLex(key, range, limit)); } @Override public Boolean hSet(byte[] key, byte[] field, byte[] value) { return helper.doInScope(RedisCommand.HSET, key, () -> connection.hSet(key, field, value)); } @Override public Boolean hSetNX(byte[] key, byte[] field, byte[] value) { return helper.doInScope(RedisCommand.HSETNX, key, () -> connection.hSetNX(key, field, value)); } @Override public byte[] hGet(byte[] key, byte[] field) { return helper.doInScope(RedisCommand.HGET, key, () -> connection.hGet(key, field)); } @Override public List<byte[]> hMGet(byte[] key, byte[]... fields) { return helper.doInScope(RedisCommand.HMGET, key, () -> connection.hMGet(key, fields)); } @Override public void hMSet(byte[] key, Map<byte[], byte[]> hashes) { helper.doInScope(RedisCommand.HMSET, key, () -> connection.hMSet(key, hashes)); } @Override public Long hIncrBy(byte[] key, byte[] field, long delta) { return helper.doInScope(RedisCommand.HINCRBY, key, () -> connection.hIncrBy(key, field, delta)); } @Override public Double hIncrBy(byte[] key, byte[] field, double delta) { return helper.doInScope(RedisCommand.HINCRBY, key, () -> connection.hIncrBy(key, field, delta)); } @Override public Boolean hExists(byte[] key, byte[] field) { return helper.doInScope(RedisCommand.HEXISTS, key, () -> connection.hExists(key, field)); } @Override public Long hDel(byte[] key, byte[]... fields) { return helper.doInScope(RedisCommand.HDEL, key, () -> connection.hDel(key, fields)); } @Override public Long hLen(byte[] key) { return helper.doInScope(RedisCommand.HLEN, key, () -> connection.hLen(key)); } @Override public Set<byte[]> hKeys(byte[] key) { return helper.doInScope(RedisCommand.HKEYS, key, () -> connection.hKeys(key)); } @Override public List<byte[]> hVals(byte[] key) { return helper.doInScope(RedisCommand.HVALS, key, () -> connection.hVals(key)); } @Override public Map<byte[], byte[]> hGetAll(byte[] key) { return helper.doInScope(RedisCommand.HGETALL, key, () -> connection.hGetAll(key)); } @Override public Cursor<Entry<byte[], byte[]>> hScan(byte[] key, ScanOptions options) { return helper.doInScope(RedisCommand.HSCAN, key, () -> connection.hScan(key, options)); } @Override public Long hStrLen(byte[] key, byte[] field) { return helper.doInScope(RedisCommand.HSTRLEN, key, () -> connection.hStrLen(key, field)); } @Override public void multi() { helper.doInScope(RedisCommand.MULTI, () -> connection.multi()); } @Override public List<Object> exec() { return helper.doInScope(RedisCommand.EXEC, () -> connection.exec()); } @Override public void discard() { helper.doInScope(RedisCommand.DISCARD, () -> connection.discard()); } @Override public void watch(byte[]... keys) { helper.doInScope(RedisCommand.WATCH, () -> connection.watch(keys)); } @Override public void unwatch() { helper.doInScope(RedisCommand.UNWATCH, () -> connection.unwatch()); } @Override public Long publish(byte[] channel, byte[] message) { return helper.doInScope(RedisCommand.PUBLISH, () -> connection.publish(channel, message)); } @Override public void subscribe(MessageListener listener, byte[]... channels) { helper.doInScope(RedisCommand.SUBSCRIBE, () -> connection.subscribe(listener, channels)); } @Override public void pSubscribe(MessageListener listener, byte[]... patterns) { helper.doInScope(RedisCommand.PSUBSCRIBE, () -> connection.pSubscribe(listener, patterns)); } @Override public void select(int dbIndex) { helper.doInScope(RedisCommand.SELECT, () -> connection.select(dbIndex)); } @Override public byte[] echo(byte[] message) { return helper.doInScope(RedisCommand.ECHO, () -> connection.echo(message)); } @Override public String ping() { return helper.doInScope(RedisCommand.PING, () -> connection.ping()); } @Override public void bgWriteAof() { helper.doInScope(RedisCommand.BGWRITEAOF, () -> connection.bgWriteAof()); } @Override public void bgReWriteAof() { helper.doInScope(RedisCommand.BGREWRITEAOF, () -> connection.bgReWriteAof()); } @Override public void bgSave() { helper.doInScope(RedisCommand.BGSAVE, () -> connection.bgSave()); } @Override public Long lastSave() { return helper.doInScope(RedisCommand.LASTSAVE, () -> connection.lastSave()); } @Override public void save() { helper.doInScope(RedisCommand.SAVE, () -> connection.save()); } @Override public Long dbSize() { return helper.doInScope(RedisCommand.DBSIZE, () -> connection.dbSize()); } @Override public void flushDb() { helper.doInScope(RedisCommand.FLUSHDB, () -> connection.flushDb()); } @Override public void flushAll() { helper.doInScope(RedisCommand.FLUSHALL, () -> connection.flushAll()); } @Override public Properties info() { return helper.doInScope(RedisCommand.INFO, () -> connection.info()); } @Override public Properties info(String section) { return helper.doInScope(RedisCommand.INFO, () -> connection.info(section)); } @Override public void shutdown() { helper.doInScope(RedisCommand.SHUTDOWN, () -> connection.shutdown()); } @Override public void shutdown(ShutdownOption option) { helper.doInScope(RedisCommand.SHUTDOWN, () -> connection.shutdown(option)); } @Override public Properties getConfig(String pattern) { return helper.doInScope(RedisCommand.CONFIG_GET, () -> connection.getConfig(pattern)); } @Override public void setConfig(String param, String value) { helper.doInScope(RedisCommand.CONFIG_SET, () -> connection.setConfig(param, value)); } @Override public void resetConfigStats() { helper.doInScope(RedisCommand.CONFIG_RESETSTAT, () -> connection.resetConfigStats()); } @Override public Long time() { return helper.doInScope(RedisCommand.TIME, () -> connection.time()); } @Override public void killClient(String host, int port) { helper.doInScope(RedisCommand.CLIENT_KILL, () -> connection.killClient(host, port)); } @Override public void setClientName(byte[] name) { helper.doInScope(RedisCommand.CLIENT_SETNAME, () -> connection.setClientName(name)); } @Override public String getClientName() { return helper.doInScope(RedisCommand.CLIENT_GETNAME, () -> connection.getClientName()); } @Override public List<RedisClientInfo> getClientList() { return helper.doInScope(RedisCommand.CLIENT_LIST, () -> connection.getClientList()); } @Override public void slaveOf(String host, int port) { helper.doInScope(RedisCommand.SLAVEOF, () -> connection.slaveOf(host, port)); } @Override public void slaveOfNoOne() { helper.doInScope(RedisCommand.SLAVEOFNOONE, () -> connection.slaveOfNoOne()); } @Override public void migrate(byte[] key, RedisNode target, int dbIndex, MigrateOption option) { helper.doInScope(RedisCommand.MIGRATE, key, () -> connection.migrate(key, target, dbIndex, option)); } @Override public void migrate(byte[] key, RedisNode target, int dbIndex, MigrateOption option, long timeout) { helper.doInScope(RedisCommand.MIGRATE, key, () -> connection.migrate(key, target, dbIndex, option, timeout)); } @Override public void scriptFlush() { helper.doInScope(RedisCommand.SCRIPT_FLUSH, () -> connection.scriptFlush()); } @Override public void scriptKill() { helper.doInScope(RedisCommand.SCRIPT_KILL, () -> connection.scriptKill()); } @Override public String scriptLoad(byte[] script) { return helper.doInScope(RedisCommand.SCRIPT_LOAD, () -> connection.scriptLoad(script)); } @Override public List<Boolean> scriptExists(String... scriptShas) { return helper.doInScope(RedisCommand.SCRIPT_EXISTS, () -> connection.scriptExists(scriptShas)); } @Override public <T> T eval(byte[] script, ReturnType returnType, int numKeys, byte[]... keysAndArgs) { return helper.doInScope(RedisCommand.EVAL, () -> connection.eval(script, returnType, numKeys, keysAndArgs)); } @Override public <T> T evalSha(String scriptSha, ReturnType returnType, int numKeys, byte[]... keysAndArgs) { return helper.doInScope(RedisCommand.EVALSHA, () -> connection.evalSha(scriptSha, returnType, numKeys, keysAndArgs)); } @Override public <T> T evalSha(byte[] scriptSha, ReturnType returnType, int numKeys, byte[]... keysAndArgs) { return helper.doInScope(RedisCommand.EVALSHA, () -> connection.evalSha(scriptSha, returnType, numKeys, keysAndArgs)); } @Override public Long geoAdd(byte[] key, Point point, byte[] member) { return helper.doInScope(RedisCommand.GEOADD, key, () -> connection.geoAdd(key, point, member)); } @Override public Long geoAdd(byte[] key, GeoLocation<byte[]> location) { return helper.doInScope(RedisCommand.GEOADD, key, () -> connection.geoAdd(key, location)); } @Override public Long geoAdd(byte[] key, Map<byte[], Point> memberCoordinateMap) { return helper .doInScope(RedisCommand.GEOADD, key, () -> connection.geoAdd(key, memberCoordinateMap)); } @Override public Long geoAdd(byte[] key, Iterable<GeoLocation<byte[]>> locations) { return helper.doInScope(RedisCommand.GEOADD, key, () -> connection.geoAdd(key, locations)); } @Override public Distance geoDist(byte[] key, byte[] member1, byte[] member2) { return helper .doInScope(RedisCommand.GEODIST, key, () -> connection.geoDist(key, member1, member2)); } @Override public Distance geoDist(byte[] key, byte[] member1, byte[] member2, Metric metric) { return helper.doInScope(RedisCommand.GEODIST, key, () -> connection.geoDist(key, member1, member2, metric)); } @Override public List<String> geoHash(byte[] key, byte[]... members) { return helper.doInScope(RedisCommand.GEOHASH, key, () -> connection.geoHash(key, members)); } @Override public List<Point> geoPos(byte[] key, byte[]... members) { return helper.doInScope(RedisCommand.GEOPOS, key, () -> connection.geoPos(key, members)); } @Override public GeoResults<GeoLocation<byte[]>> geoRadius(byte[] key, Circle within) { return helper.doInScope(RedisCommand.GEORADIUS, key, () -> connection.geoRadius(key, within)); } @Override public GeoResults<GeoLocation<byte[]>> geoRadius(byte[] key, Circle within, GeoRadiusCommandArgs args) { return helper .doInScope(RedisCommand.GEORADIUS, key, () -> connection.geoRadius(key, within, args)); } @Override public GeoResults<GeoLocation<byte[]>> geoRadiusByMember(byte[] key, byte[] member, double radius) { return helper.doInScope(RedisCommand.GEORADIUSBYMEMBER, key, () -> connection.geoRadiusByMember(key, member, radius)); } @Override public GeoResults<GeoLocation<byte[]>> geoRadiusByMember(byte[] key, byte[] member, Distance radius) { return helper.doInScope(RedisCommand.GEORADIUSBYMEMBER, key, () -> connection.geoRadiusByMember(key, member, radius)); } @Override public GeoResults<GeoLocation<byte[]>> geoRadiusByMember(byte[] key, byte[] member, Distance radius, GeoRadiusCommandArgs args) { return helper.doInScope(RedisCommand.GEORADIUSBYMEMBER, key, () -> connection.geoRadiusByMember(key, member, radius, args)); } @Override public Long geoRemove(byte[] key, byte[]... members) { return helper.doInScope(RedisCommand.GEOREMOVE, key, () -> connection.geoRemove(key, members)); } @Override public Long pfAdd(byte[] key, byte[]... values) { return helper.doInScope(RedisCommand.PFADD, key, () -> connection.pfAdd(key, values)); } @Override public Long pfCount(byte[]... keys) { return helper.doInScope(RedisCommand.PFCOUNT, keys, () -> connection.pfCount(keys)); } @Override public void pfMerge(byte[] destinationKey, byte[]... sourceKeys) { helper.doInScope(RedisCommand.PFMERGE, () -> connection.pfMerge(destinationKey, sourceKeys)); } @Override public Long xAck(byte[] key, String group, RecordId... recordIds) { return helper.doInScope(RedisCommand.XACK, () -> connection.xAck(key, group, recordIds)); } @Override public RecordId xAdd(MapRecord<byte[], byte[], byte[]> record) { return helper.doInScope(RedisCommand.XADD, () -> connection.xAdd(record)); } @Override public Long xDel(byte[] key, RecordId... recordIds) { return helper.doInScope(RedisCommand.XDEL, () -> connection.xDel(key, recordIds)); } @Override public String xGroupCreate(byte[] key, String groupName, ReadOffset readOffset) { return helper.doInScope(RedisCommand.XGROUPCREATE, () -> connection.xGroupCreate(key, groupName, readOffset)); } @Override public Boolean xGroupDelConsumer(byte[] key, Consumer consumer) { return helper.doInScope(RedisCommand.XGROUPDELCONSUMER, () -> connection.xGroupDelConsumer(key, consumer)); } @Override public Boolean xGroupDestroy(byte[] key, String groupName) { return helper .doInScope(RedisCommand.XGROUPDESTROY, () -> connection.xGroupDestroy(key, groupName)); } @Override public Long xLen(byte[] key) { return helper.doInScope(RedisCommand.XLEN, () -> connection.xLen(key)); } @Override public List<ByteRecord> xRange(byte[] key, org.springframework.data.domain.Range<String> range, Limit limit) { return helper.doInScope(RedisCommand.XRANGE, () -> connection.xRange(key, range, limit)); } @Override public List<ByteRecord> xRead(StreamReadOptions readOptions, StreamOffset<byte[]>... streams) { return helper.doInScope(RedisCommand.XREAD, () -> connection.xRead(readOptions, streams)); } @Override public List<ByteRecord> xReadGroup(Consumer consumer, StreamReadOptions readOptions, StreamOffset<byte[]>... streams) { return helper.doInScope(RedisCommand.XREADGROUP, () -> connection.xReadGroup(consumer, readOptions, streams)); } @Override public List<ByteRecord> xRevRange(byte[] key, org.springframework.data.domain.Range<String> range, Limit limit) { return helper.doInScope(RedisCommand.XREVRANGE, () -> connection.xRevRange(key, range, limit)); } @Override public Long xTrim(byte[] key, long count) { return helper.doInScope(RedisCommand.XTRIM, () -> connection.xTrim(key, count)); } }