I made mistake to use redis to store my user api JWT token, after deploying on server .
unfortunately, I have no time to replace redis with other thing and am forced to fix this on redis.

it is my redis benchmark info:

# Clients
connected_clients:28223
client_longest_output_list:0
client_biggest_input_buf:0
blocked_clients:0

I just store my Token on redis ad after user request on 1 day my redis has this error: Redix the connection to Redis is closed, then system is down .

How can I fix this?

this is my code to use Redis:

defmodule BankError.Extera.Redis do

  def connect_to_redis do
    case Redix.start_link() do
    {:ok, conn} ->
      Redix.pipeline(conn, [["AUTH","PASSWORD"]]) # will be changed
      {:ok, conn, :connect_to_redis}
      _ -> {:error, :connect_to_redis}
    end
	end

  def insert_or_update_into_redis(table_name, record_id, params, expire_time) do
    with {:ok, conn, :connect_to_redis} <- connect_to_redis() do
      conn |>
      Redix.pipeline([
        List.flatten(
          [
            "HMSET",
            # String.to_charlist(table_name <> record_id)
            "#{table_name}#{record_id}"
          ], BankError.map_to_single_list_with_string_key(params)
        ),
        [
          "EXPIRE",
          table_name <> record_id,
          expire_time
        ]
      ])
      {:ok, :insert_or_update_into_redis}
    end
  end

  @doc """
    show all fields of redis record
  """
  def get_all_fields_of_record_redis(table_name, record_id) do
		with {:ok, conn, :connect_to_redis} <- connect_to_redis() do
      conn
      |> Redix.pipeline!([["HGETALL",table_name <> record_id]])
    else
      n ->
        {:error, :get_all_fields_of_record_redis, n}
    end
	end

  @doc """
    show singel fields of redis record
  """
  def get_singel_field_record_of_redis(table_name, record_id, field_name) do
    with {:ok, conn, :connect_to_redis} <- connect_to_redis() do
      conn
      |> Redix.pipeline!([["HGET","#{table_name}#{record_id}", field_name]])
    else
      n ->
        {:error, :get_singel_field_record_of_redis, n}
    end
  end

  @doc """
    delete redis record
  """
  def delete_record_of_redis(table_name, record_id) do
    with {:ok, conn, :connect_to_redis} <- connect_to_redis(),
         {:ok, :get_all_fields_of_record_redis, record} <- convert_output_of_get_all_fields_of_record_redis(get_all_fields_of_record_redis(table_name, record_id)) do

          conn
          |> Redix.pipeline([["HDEL", table_name <> record_id] ++ record])
          {:ok, :delete_record_of_redis, "The record is deleted"}
    else
      n ->  n
    end
  end

  def convert_output_of_get_all_fields_of_record_redis(params) do
    case params do
      [[]] -> {:error, :get_all_fields_of_record_redis, "The data concerned doesn't exist"}
      [] -> {:error, :get_all_fields_of_record_redis, "The data concerned doesn't exist"}
      [nil] -> {:error, :get_all_fields_of_record_redis, "The data concerned doesn't exist"}
      n ->
        [record | _] = n
        {:ok, :get_all_fields_of_record_redis, record}
    end
  end

  @doc """
    delete singel field of redis record
  """
  def delete_field_of_record_redis(table_name, record_id, field_name) do

    with {:ok, conn, :connect_to_redis} <- connect_to_redis(),
         {:ok, :get_all_fields_of_record_redis, _record} <- convert_output_of_get_all_fields_of_record_redis(get_all_fields_of_record_redis(table_name, record_id)),
         {:ok, [1]} <- Redix.pipeline(conn, [["HDEL", table_name <> record_id, field_name]]) do

          {:ok, :delete_field_of_record_redis}
    else
      {:ok, [0]} -> {:error, :delete_field_of_record_redis, "The field you need doesn't exist"}
      n -> n
    end
  end

  @doc """
    get expire time of singel record
  """
  def get_expire_time_of_redis(table_name, record_id) do
    with {:ok, conn, :connect_to_redis} <- connect_to_redis(),
        {:ok, :get_expire_time_error_handler, expire_time} <- get_expire_time_error_handler(conn, table_name, record_id) do

        {:ok, :get_expire_time, expire_time}
    else
      n -> n
    end
  end

  defp get_expire_time_error_handler(conn, table_name, record_id) do
    case Redix.pipeline(conn, [["TTL",table_name <> record_id]]) do
      {:ok, [-2]} ->
        {:error, :get_expire_time_error_handler, "The data concerned doesn't exist"}

      {:ok, [expire_time]} ->
        {:ok, :get_expire_time_error_handler, expire_time}

      _ ->
      {:error, :get_expire_time_error_handler, "The data concerned doesn't exist"}
    end
  end

  @doc """
    get expire time of singel record
  """
  def update_expire_time_of_redis(table_name, record_id, expire_time) do
    with {:ok, conn, :connect_to_redis} <- connect_to_redis(),
        {:ok, :update_expire_time_of_error_handler, msg} <- update_expire_time_of_error_handler(conn, table_name, record_id, expire_time) do

        {:ok, :update_expire_time_of_redis, msg}
    else
      n -> n
    end
  end

  defp update_expire_time_of_error_handler(conn, table_name, record_id, expire_time) do
    case Redix.pipeline(conn, [["EXPIRE",table_name <> record_id, expire_time]]) do
      {:ok, [0]} ->
        {:error, :update_expire_time_of_error_handler, "The data concerned doesn't exist"}

      {:ok, [1]} ->
        {:ok, :update_expire_time_of_error_handler, "The data concerned was updated"}

      _ ->
      {:error, :update_expire_time_of_error_handler, "The data concerned doesn't exist"}
    end
  end

end

and my Supervisor on redis

defmodule BankError.Extera.RedisSup do
   @pool_size 1000

  def child_spec(_args) do
    # Specs for the Redix connections.
    children =
      for i <- 0..(@pool_size - 1) do
        Supervisor.child_spec({Redix, name: :"redix_#{i}"}, id: {Redix, i})
      end

    # Spec for the supervisor that will supervise the Redix connections.
    %{
      id: RedixSupervisor,
      type: :supervisor,
      start: {Supervisor, :start_link, [children, [strategy: :one_for_one]]}
    }
  end

for example I use Redis like this:

in my controller:

  def brands(conn, %{"category_id" => category_id, "token" => token}) do
    with {:ok, :is_token_validated?, id} <- UserQuery.is_token_validated?(token),
     {:ok, :api_user_check_mobile_and_subscribe, _user_info, _subscriber_info} <- UserQuery.api_user_check_mobile_and_subscribe(id) do

      conn
      |> put_status(200)
      |> json(%{brands: Error.show_error_brands(category_id)})
    end
  end

and Redix code:

  def is_token_validated?(token) do
    with {:ok, claims} <- verify_token(token),
         {:ok, %{id: id}} <- get_id_from_jwt_climes(claims),
         {:ok, :get_all_fields_of_record_redis, record_of_user_token} <- BankError.Extera.Redis.convert_output_of_get_all_fields_of_record_redis(BankError.Extera.Redis.get_all_fields_of_record_redis("user_token", id)),
         %{"token" => redis_token} <- BankError.list_to_map(record_of_user_token),
         {:ok, :change_password_token_on_check} <- change_password_token_on_check(token, redis_token) do

        {:ok, :is_token_validated?, id}

      else
        _ ->
          {:error, :is_token_validated?}
    end
  end

Thanks