Merge branch 'main' into latest

Author: cmilesb

.github/workflows/redis_docs_sync.yaml

@@ -0,0 +1,104 @@
+name: redis_docs_sync
+
+on:
+  workflow_dispatch:
+    inputs:
+      release:
+        type: string
+        required: true
+        description: ''
+
+jobs:
+  redis_docs_sync:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      actions: write
+    steps:
+      - name: Generate a token
+        id: generate-token
+        uses: actions/create-github-app-token@v1
+        with:
+          app-id: ${{ secrets.DOCS_APP_ID }}
+          private-key: ${{ secrets.DOCS_APP_PRIVATE_KEY }}
+
+      - name: 'Checkout'
+        uses: actions/checkout@v3
+        with:
+          token: ${{ steps.generate-token.outputs.token }}
+
+      - name: 'Generate modules-api-ref.md and commands.json files and push if necessary'
+        env:
+          GH_TOKEN: ${{ steps.generate-token.outputs.token }}
+        run: |-
+          RELEASE="${{ github.event.inputs.release }}"
+          BRANCH="redis_docs_sync_${RELEASE}"
+
+          # Generate modules-api-ref.md
+          gh repo clone redis/redis
+          pushd redis
+          git fetch origin --tags
+          git checkout "tags/${RELEASE}"
+          make 1>/dev/null
+          src/redis-server &
+          utils/generate-commands-json.py  > generated-commands.json
+          utils/generate-module-api-doc.rb > generated-modules-api-ref.md
+          popd
+
+          # check if remote branch already exists
+          git fetch --all
+          set +e
+          git ls-remote --exit-code --heads origin "refs/heads/${BRANCH}"
+          if [ "$?" -eq 0 ]; then
+            set -e
+            # if it does, create local branch off existing remote branch
+            git checkout -b "${BRANCH}" "origin/${BRANCH}"
+            git branch --set-upstream-to="origin/${BRANCH}" "${BRANCH}"
+            git pull
+          else
+            set -e
+            # otherwise, create local branch from main
+            git checkout -b "${BRANCH}"
+          fi
+
+          mv redis/generated-modules-api-ref.md content/develop/reference/modules/modules-api-ref.md
+          mv redis/generated-commands.json data/commands_core.json
+
+          # Apply frontmatter patch
+          git apply content/develop/reference/modules/modules-api-ref-frontmatter.patch
+
+          # Check if there are any changes
+          commands_core_is_different=$(git diff data/commands_core.json)
+          modules_api_is_different=$(git diff content/develop/reference/modules/modules-api-ref.md)
+
+          # If commands_core file has changed, commit it
+          if [[ ! -z $commands_core_is_different ]]; then
+            git add data/commands_core.json
+            git config user.email "177626021+redisdocsapp[bot]@users.noreply.github.com"
+            git config user.name "redisdocsapp[bot]"
+            git commit -m "Update commands_core.json for release ${RELEASE}"
+          fi
+
+          # If modules-api-ref file has changed, commit it
+          if [[ ! -z $modules_api_is_different ]]; then
+            git add content/develop/reference/modules/modules-api-ref.md
+            git config user.email "177626021+redisdocsapp[bot]@users.noreply.github.com"
+            git config user.name "redisdocsapp[bot]"
+            git commit -m "Update modules-api-ref.md for release ${RELEASE}"
+          fi
+
+          if [[ ! -z $commands_core_is_different || ! -z $modules_api_is_different ]]; then
+            git push origin "${BRANCH}"
+          fi
+
+          # If a pr is not already open, create one
+          set +e
+          gh search prs -R redis/docs --state open --match title "redis docs sync ${RELEASE}" | grep -q "redis docs sync ${RELEASE}"
+          if [ "$?" -eq 1 ]; then
+            set -e
+            gh pr create \
+              --body "redis docs sync ${RELEASE}" \
+              --title "redis docs sync ${RELEASE}" \
+              --head "$BRANCH" \
+              --base "main"
+          fi

content/commands/client-trackinginfo/index.md

@@ -43,5 +43,5 @@ Here's the list of tracking information sections and their respective values:
   * `caching-no`: The next command won't cache keys (exists only together with `optout`).
   * `noloop`: The client isn't notified about keys modified by itself.
   * `broken_redirect`: The client ID used for redirection isn't valid anymore.
-* **redirect**: The client ID used for notifications redirection, or -1 when none.
+* **redirect**: The client ID used for notifications redirection, 0 for self-redirection, or -1 when none.
 * **prefixes**: A list of key prefixes for which notifications are sent to the client.

content/commands/ft.aggregate/index.md

@@ -173,7 +173,7 @@ syntax: "FT.AGGREGATE index query \n  [VERBATIM] \n  [LOAD count field [field ..
   \ ...]] ...]] \n  [ SORTBY nargs [ property ASC | DESC [ property ASC | DESC ...]]\
   \ [MAX num] [WITHCOUNT] \n  [ APPLY expression AS name [ APPLY expression AS name\
   \ ...]] \n  [ LIMIT offset num] \n  [FILTER filter] \n  [ WITHCURSOR [COUNT read_size]\
-  \ [MAXIDLE idle_time]] \n  [ PARAMS nargs name value [ name value ...]] \n  [DIALECT\
+  \ [MAXIDLE idle_time]] \n  [ PARAMS nargs name value [ name value ...]] \n  [ADDSCORES] \n  [DIALECT\
   \ dialect]\n"
 syntax_fmt: "FT.AGGREGATE index query [VERBATIM] [LOAD\_count field [field ...]]\n\
   \  [TIMEOUT\_timeout] [LOAD *] [GROUPBY\_nargs property [property ...]\n  [REDUCE\_\
@@ -183,15 +183,15 @@ syntax_fmt: "FT.AGGREGATE index query [VERBATIM] [LOAD\_count field [field ...]]
   name] ...]] ...]]\n  [SORTBY\_nargs [property <ASC | DESC> [property <ASC | DESC>\
   \ ...]]\n  [MAX\_num]] [APPLY\_expression AS\_name [APPLY\_expression AS\_name\n\
   \  ...]] [LIMIT offset num] [FILTER\_filter] [WITHCURSOR\n  [COUNT\_read_size] [MAXIDLE\_\
-  idle_time]] [PARAMS nargs name value\n  [name value ...]] [DIALECT\_dialect]"
+  idle_time]] [PARAMS nargs name value\n  [name value ...]]\n  [ADDSCORES]\n  [DIALECT\_dialect]"
 syntax_str: "query [VERBATIM] [LOAD\_count field [field ...]] [TIMEOUT\_timeout] [LOAD\
   \ *] [GROUPBY\_nargs property [property ...] [REDUCE\_function nargs arg [arg ...]\
   \ [AS\_name] [REDUCE\_function nargs arg [arg ...] [AS\_name] ...]] [GROUPBY\_nargs\
   \ property [property ...] [REDUCE\_function nargs arg [arg ...] [AS\_name] [REDUCE\_\
   function nargs arg [arg ...] [AS\_name] ...]] ...]] [SORTBY\_nargs [property <ASC\
   \ | DESC> [property <ASC | DESC> ...]] [MAX\_num]] [APPLY\_expression AS\_name [APPLY\_\
   expression AS\_name ...]] [LIMIT offset num] [FILTER\_filter] [WITHCURSOR [COUNT\_\
-  read_size] [MAXIDLE\_idle_time]] [PARAMS nargs name value [name value ...]] [DIALECT\_\
+  read_size] [MAXIDLE\_idle_time]] [PARAMS nargs name value [name value ...]] [ADDSCORES] [DIALECT\_\
   dialect]"
 title: FT.AGGREGATE
 ---
@@ -316,6 +316,15 @@ defines one or more value parameters. Each parameter has a name and a value.
 You can reference parameters in the `query` by a `$`, followed by the parameter name, for example, `$user`. Each such reference in the search query to a parameter name is substituted by the corresponding parameter value. For example, with parameter definition `PARAMS 4 lon 29.69465 lat 34.95126`, the expression `@loc:[$lon $lat 10 km]` is evaluated to `@loc:[29.69465 34.95126 10 km]`. You cannot reference parameters in the query string where concrete values are not allowed, such as in field names, for example, `@loc`. To use `PARAMS`, set `DIALECT` to `2` or greater than `2`.
 </details>
 
+<details open>
+<summary><code>ADDSCORES</code></summary>
+
+The `ADDSCORES` option exposes the full-text score values to the aggregation pipeline.
+You can use `@__score` in a pipeline as shown in the following example:
+
+`FT.AGGREGATE idx 'hello' ADDSCORES SORTBY 2 @__score DESC`
+</details>
+
 <details open>
 <summary><code>DIALECT {dialect_version}</code></summary> 
 

content/develop/connect/clients/java/_index.md

@@ -20,7 +20,7 @@ You have two choices of Java clients that you can use with Redis:
 
 -   [Jedis]({{< relref "/develop/connect/clients/java/jedis" >}}), for synchronous applications.
 -   [Lettuce]({{< relref "/develop/connect/clients/java/lettuce" >}}),
-    for asynchronous and reactive applications.
+    for synchronous, asynchronous, and reactive applications.
 
 You can also access Redis with an object-mapping client interface. See
 [RedisOM for Java]({{< relref "/integrate/redisom-for-java" >}})

content/develop/connect/clients/java/jedis.md

@@ -15,9 +15,9 @@ title: Jedis guide
 weight: 1
 ---
 
-[Jedis](https://github.com/redis/jedis) is the *synchronous* Java client for Redis.
+[Jedis](https://github.com/redis/jedis) is a synchronous Java client for Redis.
 Use [Lettuce]({{< relref "/develop/connect/clients/java/lettuce" >}}) if you need
-an *asynchronous* Java client.
+a more advanced Java client that also supports asynchronous and reactive connections.
 The sections below explain how to install `Jedis` and connect your application
 to a Redis database.
 

content/develop/connect/clients/java/lettuce.md

@@ -15,9 +15,11 @@ title: Lettuce guide
 weight: 2
 ---
 
-[Lettuce](https://github.com/redis/lettuce/tree/main/src/main) is the *asynchronous* Java client for Redis.
-Use [Jedis]({{< relref "/develop/connect/clients/java/jedis" >}}) if you need
-a *synchronous* Java client.
+[Lettuce](https://github.com/redis/lettuce/tree/main/src/main) is an advanced Java client for Redis
+that supports synchronous, asynchronous, and reactive connections.
+If you only need synchronous connections then you may find the other Java client
+[Jedis]({{< relref "/develop/connect/clients/java/jedis" >}}) easier to use.
+
 The sections below explain how to install `Lettuce` and connect your application
 to a Redis database.
 
@@ -94,7 +96,7 @@ public class Async {
 }
 ```
 
-Learn more about asynchronous Lettuce API in [the reference guide](https://lettuce.io/core/release/reference/index.html#asynchronous-api).
+Learn more about asynchronous Lettuce API in [the reference guide](https://redis.github.io/lettuce/#asynchronous-api).
 
 ### Reactive connection
 
@@ -136,7 +138,7 @@ public class Main {
 }
 ```
 
-Learn more about reactive Lettuce API in [the reference guide](https://lettuce.io/core/release/reference/index.html#reactive-api).
+Learn more about reactive Lettuce API in [the reference guide](https://redis.github.io/lettuce/#reactive-api).
 
 ### Redis Cluster connection
 
@@ -178,14 +180,15 @@ RedisClient client = RedisClient.create(redisUri);
 Lettuce uses `ClientResources` for efficient management of shared resources like event loop groups and thread pools.
 For connection pooling, Lettuce leverages `RedisClient` or `RedisClusterClient`, which can handle multiple concurrent connections efficiently.
 
-### Timouts
+### Timeouts
+
 Lettuce provides timeouts for many operations, such as command execution, SSL handshake, and Sentinel discovery. By default, Lettuce uses a global timeout value of 60 seconds for these operations, but you can override the global timeout value with individual timeout values for each operation.
 
 {{% alert title="Tip" color="warning" %}}
 Choosing suitable timeout values is crucial for your application's performance and stability and is specific to each environment.
 Configuring timeouts is only necessary if you have issues with the default values. 
 In some cases, the defaults are based on environment-specific settings (e.g., operating system settings), while in other cases, they are built into the Lettuce driver. 
-For more details on setting specific timeouts, see the [Lettuce reference guide](https://lettuce.io/core/release/reference/index.html).
+For more details on setting specific timeouts, see the [Lettuce reference guide](https://redis.github.io/lettuce/).
 {{% /alert  %}}
 
 Below is an example of setting socket-level timeouts. The `TCP_USER_TIMEOUT` setting is useful for scenarios where the server stops responding without acknowledging the last request, while the `KEEPALIVE` setting is good for detecting dead connections where there is no traffic between the client and the server.
@@ -228,6 +231,7 @@ try (RedisClient client = RedisClient.create(redisURI)) {
 ```
 
 ### Connection pooling
+
 A typical approach with Lettuce is to create a single `RedisClient` instance and reuse it to establish connections to your Redis server(s).
 These connections are multiplexed; that is, multiple commands can be run concurrently over a single or a small set of connections, making explicit pooling less practical.
 
@@ -300,6 +304,6 @@ java.security.Security.setProperty("networkaddress.cache.negative.ttl", "0");
 
 ## Learn more
 
-- [Lettuce reference documentation](https://lettuce.io/docs/)
+- [Lettuce reference documentation](https://redis.github.io/lettuce/)
 - [Redis commands]({{< relref "/commands" >}})
 - [Project Reactor](https://projectreactor.io/)

content/develop/data-types/hashes.md

@@ -144,45 +144,47 @@ Consider a hash data set for storing sensor data that has the following structur
 ```python
 event = {
     'air_quality': 256,
-    'Battery_level':89
+    'battery_level':89
 }
 
-client.hset('sensor:sensor1', mapping=event)
+r.hset('sensor:sensor1', mapping=event)
 ```
 
+In the examples below, you will likely need to refresh the `sensor:sensor1` key after its fields expire.
+
 Set and retrieve the TTL for multiple fields in a hash:
 
 ```python
 # set the TTL for two hash fields to 60 seconds
-client.hexpire('sensor:sensor1', 60, 'air_quality', 'battery_level')
-ttl = client.httl('sensor:sensor1', 'air_quality', 'battery_level')
+r.hexpire('sensor:sensor1', 60, 'air_quality', 'battery_level')
+ttl = r.httl('sensor:sensor1', 'air_quality', 'battery_level')
 print(ttl)
-# prints [60]
+# prints [60, 60]
 ```
 
 Set and retrieve a hash field's TTL in milliseconds:
 
 ```python
 # set the TTL of the 'air_quality' field in milliseconds
-client.hpexpire('sensor:sensor1', 60000, 'air_quality')
+r.hpexpire('sensor:sensor1', 60000, 'air_quality')
 # and retrieve it
-pttl = client.hpttl('sensor:sensor1', 'air_quality')
+pttl = r.hpttl('sensor:sensor1', 'air_quality')
 print(pttl)
-# prints [60000]
+# prints [59994] # your actual value may vary
 ```
 
 Set and retrieve a hash field’s expiration timestamp:
 
 ```python
 # set the expiration of 'air_quality' to now + 24 hours
 # (similar to setting the TTL to 24 hours)
-client.hexpireat('sensor:sensor1', 
+r.hexpireat('sensor:sensor1', 
     datetime.now() + timedelta(hours=24), 
     'air_quality')
 # and retrieve it
-expire_time = client.hexpiretime('sensor:sensor1', 'air_quality')
+expire_time = r.hexpiretime('sensor:sensor1', 'air_quality')
 print(expire_time)
-# prints [1717668041]
+# prints [1717668041] # your actual value may vary
 ```
 
 ## Performance

content/embeds/r7.2-migration-guides.md

@@ -1,6 +1,6 @@
 ### Migration guides for certain clients
 
-If you are using [Go-Redis](https://redis.uptrace.dev/) v9 or [Lettuce](https://lettuce.io/) v6+, which by default switch to the RESP3 protocol, and you are running Redis Stack commands, please make sure the protocol version is pinned to RESP2 prior to upgrading to Redis version 7.2.
+If you are using [Go-Redis](https://redis.uptrace.dev/) v9 or [Lettuce](https://redis.github.io/lettuce/) v6+, which by default switch to the RESP3 protocol, and you are running Redis Stack commands, please make sure the protocol version is pinned to RESP2 prior to upgrading to Redis version 7.2.
 
 #### Go-Redis
 

content/embeds/rc-create-db-first-steps.md

@@ -2,7 +2,7 @@ Before creating a Redis Cloud database, you need to [create an account]({{< relr
 
 To create a database in your Redis Cloud account:
 
-1. Sign in to the [Redis Cloud console](https://app.redislabs.com).
+1. Sign in to the [Redis Cloud console](https://cloud.redis.io).
 
 2. Select the **New database** button.
 

content/get-started/_index.md

@@ -9,12 +9,12 @@ Redis is an [in-memory data store]({{< relref "/develop/get-started/data-store"
 
 You can install Redis from source, from an executable for your OS, or bundled with Redis Stack and Redis Insight which include popular features and monitoring.
 
-* [Install Redis from Source]({{< relref "/operate/oss_and_stack/install/install-redis/install-redis-from-source" >}})
 * [Install Redis on Linux]({{< relref "/operate/oss_and_stack/install/install-redis/install-redis-on-linux" >}})
 * [Install Redis on macOS]({{< relref "/operate/oss_and_stack/install/install-redis/install-redis-on-mac-os" >}})
 * [Install Redis on Windows]({{< relref "/operate/oss_and_stack/install/install-redis/install-redis-on-windows" >}})
 * [Install Redis with Redis Stack and Redis Insight]({{< relref "/operate/oss_and_stack/install/install-stack" >}})
 * [Run Redis Stack on Docker]({{< relref "/operate/oss_and_stack/install/install-stack/docker" >}})
+* [Install Redis from Source]({{< relref "/operate/oss_and_stack/install/install-redis/install-redis-from-source" >}})
 
 ## Use cases