From 39c097dae8a74370f3429e03f4a3d0808a125885 Mon Sep 17 00:00:00 2001 From: Lucas Kent Date: Mon, 25 Nov 2024 11:36:57 +1100 Subject: [PATCH] Rename "redis" -> "valkey" in transforms.md --- docs/src/transforms.md | 60 +++++++++++++++++++++--------------------- 1 file changed, 30 insertions(+), 30 deletions(-) diff --git a/docs/src/transforms.md b/docs/src/transforms.md index ffba4a09b..832d31151 100644 --- a/docs/src/transforms.md +++ b/docs/src/transforms.md @@ -39,10 +39,10 @@ Future transforms won't be added to the public API while in alpha. But in these | [Protect](#protect) | ❌ | Alpha | | [QueryCounter](#querycounter) | ❌ | Alpha | | [QueryTypeFilter](#querytypefilter) | ❌ | Alpha | -| [RedisCache](#rediscache) | ❌ | Alpha | -| [RedisClusterPortsRewrite](#redisclusterportsrewrite) | ❌ | Beta | -| [RedisSinkCluster](#redissinkcluster) | ✅ | Beta | -| [RedisSinkSingle](#redissinksingle) | ✅ | Beta | +| [ValkeyCache](#rediscache) | ❌ | Alpha | +| [ValkeyClusterPortsRewrite](#redisclusterportsrewrite) | ❌ | Beta | +| [ValkeySinkCluster](#redissinkcluster) | ✅ | Beta | +| [ValkeySinkSingle](#redissinksingle) | ✅ | Beta | | [Tee](#tee) | ✅ | Alpha | | [RequestThrottling](#requestthrottling) |❌ | Alpha | @@ -217,8 +217,8 @@ This transform will drop any messages it receives and return the supplied respon ```yaml - DebugReturner - # return a Redis response - Redis: "42" + # return a Valkey response + Valkey: "42" # To intentionally fail, use this variant # Fail @@ -400,7 +400,7 @@ If we have a parallelism of 3 then we would have 3 instances of the chain: C1, C chain: - QueryCounter: name: "DR chain" - - RedisSinkSingle: + - ValkeySinkSingle: remote_address: "127.0.0.1:6379" connect_timeout_ms: 3000 ``` @@ -480,45 +480,45 @@ This transform will drop messages that match the specified filter. You can eithe # DenyList: [Write, ReadWrite, SchemaChange, PubSubMessage] ``` -### RedisCache +### ValkeyCache -This transform will attempt to cache values for a given primary key in a Redis hash set. It is a primarily implemented as a read behind cache. It currently expects an SQL based AST to figure out what to cache (e.g. CQL, PGSQL) and updates to the cache and the backing datastore are performed sequentially. +This transform will attempt to cache values for a given primary key in a Valkey hash set. It is a primarily implemented as a read behind cache. It currently expects an SQL based AST to figure out what to cache (e.g. CQL, PGSQL) and updates to the cache and the backing datastore are performed sequentially. ```yaml -- RedisCache: +- ValkeyCache: caching_schema: test: partition_key: [test] range_key: [test] chain: - # The chain can contain anything but must end in a Redis sink - - RedisSinkSingle: + # The chain can contain anything but must end in a Valkey sink + - ValkeySinkSingle: # The IP address and port of the upstream redis node/service. remote_address: "127.0.0.1:6379" connect_timeout_ms: 3000 ``` -### RedisClusterPortsRewrite +### ValkeyClusterPortsRewrite -This transform should be used with the `RedisSinkCluster` transform. It will write over the ports of the nodes returned by `CLUSTER SLOTS` or `CLUSTER NODES` with a user supplied value (typically the port that Shotover is listening on so cluster aware Redis drivers will direct traffic through Shotover instead of the nodes themselves). +This transform should be used with the `ValkeySinkCluster` transform. It will write over the ports of the nodes returned by `CLUSTER SLOTS` or `CLUSTER NODES` with a user supplied value (typically the port that Shotover is listening on so cluster aware Valkey drivers will direct traffic through Shotover instead of the nodes themselves). ```yaml -- RedisClusterPortsRewrite: +- ValkeyClusterPortsRewrite: # rewrite the ports returned by `CLUSTER SLOTS` and `CLUSTER NODES` to use this port. new_port: 6380 ``` -### RedisSinkCluster +### ValkeySinkCluster -This transform is a full featured Redis driver that will connect to a Redis cluster and handle all discovery, sharding and routing operations. +This transform is a full featured Valkey driver that will connect to a Valkey cluster and handle all discovery, sharding and routing operations. ```yaml -- RedisSinkCluster: +- ValkeySinkCluster: # A list of IP address and ports of the upstream redis nodes/services. first_contact_points: ["127.0.0.1:2220", "127.0.0.1:2221", "127.0.0.1:2222", "127.0.0.1:2223", "127.0.0.1:2224", "127.0.0.1:2225"] - # By default RedisSinkCluster will attempt to emulate a single non-clustered redis node by completely hiding the fact that redis is a cluster. + # By default ValkeySinkCluster will attempt to emulate a single non-clustered redis node by completely hiding the fact that redis is a cluster. # However, when this field is provided, this cluster hiding is disabled. # Instead other nodes in the cluster will only be accessed when performing a command that accesses a slot. # All other commands will be passed directly to the direct_connection node. @@ -547,29 +547,29 @@ This transform is a full featured Redis driver that will connect to a Redis clus # #verify_hostname: true ``` -Unlike other Redis cluster drivers, this transform does support pipelining. It does however turn each command from the pipeline into a group of requests split between the master Redis node that owns them, buffering results as within different Redis nodes as needed. This is done sequentially and there is room to make this transform split requests between master nodes in a more concurrent manner. +Unlike other Valkey cluster drivers, this transform does support pipelining. It does however turn each command from the pipeline into a group of requests split between the master Valkey node that owns them, buffering results as within different Valkey nodes as needed. This is done sequentially and there is room to make this transform split requests between master nodes in a more concurrent manner. -Latency and throughput will be different from pipelining with a single Redis node, but not by much. +Latency and throughput will be different from pipelining with a single Valkey node, but not by much. -This transform emits a metrics [counter](user-guide/observability.md#counter) named `failed_requests` and the labels `transform` defined as `RedisSinkCluster` and `chain` as the name of the chain that this transform is in. +This transform emits a metrics [counter](user-guide/observability.md#counter) named `failed_requests` and the labels `transform` defined as `ValkeySinkCluster` and `chain` as the name of the chain that this transform is in. -#### Differences to real Redis +#### Differences to real Valkey -On an existing authenticated connection, a failed auth attempt will not "unauthenticate" the user. This behaviour matches Redis 6 but is different to Redis 5. +On an existing authenticated connection, a failed auth attempt will not "unauthenticate" the user. This behaviour matches Valkey 6 but is different to Valkey 5. #### Completeness -_Note: Currently RedisSinkcluster does not support the following functionality:_ +_Note: Currently ValkeySinkcluster does not support the following functionality:_ -* _Redis Transactions_ +* _Valkey Transactions_ * _Scan based operations e.g. SSCAN_ -### RedisSinkSingle +### ValkeySinkSingle -This transform will take a query, serialise it into a RESP2 compatible format and send to the Redis compatible database at the defined address. +This transform will take a query, serialise it into a RESP2 compatible format and send to the Valkey compatible database at the defined address. ```yaml -- RedisSinkSingle: +- ValkeySinkSingle: # The IP address and port of the upstream redis node/service. remote_address: "127.0.0.1:6379" @@ -592,7 +592,7 @@ This transform will take a query, serialise it into a RESP2 compatible format an Note: this will just pass the query to the remote node. No cluster discovery or routing occurs with this transform. -This transform emits a metrics [counter](user-guide/observability.md#counter) named `failed_requests` and the labels `transform` defined as `RedisSinkSingle` and `chain` as the name of the chain that this transform is in. +This transform emits a metrics [counter](user-guide/observability.md#counter) named `failed_requests` and the labels `transform` defined as `ValkeySinkSingle` and `chain` as the name of the chain that this transform is in. ### Tee