Module: Valkey::Commands::ServerCommands

Included in:
Valkey::Commands
Defined in:
lib/valkey/commands/server_commands.rb

Overview

this module contains commands related to server management.

See Also:

Instance Method Summary collapse

Instance Method Details

#acl(subcommand, *args) ⇒ Object

Control ACL configuration (convenience method).

Examples:

List all categories

valkey.acl(:cat)
  # => ["keyspace", "read", ...]

Delete a user

valkey.acl(:deluser, "alice")
  # => 1

Test command execution

valkey.acl(:dryrun, "alice", "get", "key1")
  # => "OK"

Generate a password

valkey.acl(:genpass)
  # => "dd721260..."

Get user info

valkey.acl(:getuser, "alice")
  # => [...]

List all ACL rules

valkey.acl(:list)
  # => ["user default on ...", ...]

Reload ACL from file

valkey.acl(:load)
  # => "OK"

Get ACL log

valkey.acl(:log)
  # => [...]

Save ACL to file

valkey.acl(:save)
  # => "OK"

Set user rules

valkey.acl(:setuser, "alice", "on", ">password")
  # => "OK"

List all users

valkey.acl(:users)
  # => ["default", "alice"]

Get current username

valkey.acl(:whoami)
  # => "default"

Parameters:

  • subcommand (String, Symbol) —

    the subcommand (cat, deluser, dryrun, genpass, getuser, list, load, log, save, setuser, users, whoami)

  • args (Array) —

    arguments for the subcommand

Returns:

  • (Object) —

    depends on subcommand



483
484
485
486
 
# File 'lib/valkey/commands/server_commands.rb', line 483

def acl(subcommand, *args)
  subcommand = subcommand.to_s.downcase
  send("acl_#{subcommand}", *args)
end

#acl_cat(category = nil) ⇒ Array<String>

List the ACL categories or the commands inside a category.

Examples:

List all categories

valkey.acl_cat
  # => ["keyspace", "read", "write", ...]

List commands in a category

valkey.acl_cat("dangerous")
  # => ["flushdb", "flushall", ...]

Parameters:

  • category (String) (defaults to: nil) —

    optional category name to list commands

Returns:

  • (Array<String>) —

    array of categories or commands

See Also:



258
259
260
261
 
# File 'lib/valkey/commands/server_commands.rb', line 258

def acl_cat(category = nil)
  args = category ? [category] : []
  send_command(RequestType::ACL_CAT, args)
end

#acl_deluser(*usernames) ⇒ Integer

Remove the specified ACL users.

Examples:

Delete a user

valkey.acl_deluser("alice")
  # => 1

Delete multiple users

valkey.acl_deluser("alice", "bob")
  # => 2

Parameters:

  • usernames (Array<String>) —

    one or more usernames to delete

Returns:

  • (Integer) —

    number of users deleted

See Also:



276
277
278
 
# File 'lib/valkey/commands/server_commands.rb', line 276

def acl_deluser(*usernames)
  send_command(RequestType::ACL_DEL_USER, usernames)
end

#acl_dryrun(username, command, *args) ⇒ String

Simulate the execution of a command by a user without actually running it.

Examples:

Test if user can run a command

valkey.acl_dryrun("alice", "get", "key1")
  # => "OK"

Test a command that would be denied

valkey.acl_dryrun("alice", "set", "key1", "value")
  # => "This user has no permissions to run the 'set' command"

Parameters:

  • username (String) —

    the username to test

  • command (String) —

    the command to test

  • args (Array<String>) —

    command arguments

Returns:

  • (String) —

    "OK" if allowed, or error message if denied

See Also:



295
296
297
298
 
# File 'lib/valkey/commands/server_commands.rb', line 295

def acl_dryrun(username, command, *args)
  command_args = [username, command] + args
  send_command(RequestType::ACL_DRY_RUN, command_args)
end

#acl_genpass(bits = nil) ⇒ String

Generate a random password.

Examples:

Generate a password with default length

valkey.acl_genpass
  # => "dd721260bfe1b3d9601e7fbab36de6d04e2e67b0ef1c53de59d45950db0dd3cc"

Generate a password with specific bit length

valkey.acl_genpass(32)
  # => "355ef3dd"

Parameters:

  • bits (Integer) (defaults to: nil) —

    optional number of bits (default: 256)

Returns:

  • (String) —

    the generated password

See Also:



313
314
315
316
 
# File 'lib/valkey/commands/server_commands.rb', line 313

def acl_genpass(bits = nil)
  args = bits ? [bits] : []
  send_command(RequestType::ACL_GEN_PASS, args)
end

#acl_getuser(username) ⇒ Array?

Get the rules for a specific ACL user.

Examples:

Get user rules

valkey.acl_getuser("alice")
  # => ["flags" => ["on", "allkeys"], "passwords" => [...], ...]

Parameters:

  • username (String) —

    the username to query

Returns:

  • (Array, nil) —

    array of user properties, or nil if user doesn't exist

See Also:



328
329
330
 
# File 'lib/valkey/commands/server_commands.rb', line 328

def acl_getuser(username)
  send_command(RequestType::ACL_GET_USER, [username])
end

#acl_list ⇒ Array<String>

List the current ACL rules in ACL config file format.

Examples:

List all ACL rules

valkey.acl_list
  # => ["user default on nopass ~* &* +@all", "user alice on ..."]

Returns:

  • (Array<String>) —

    array of ACL rules

See Also:



341
342
343
 
# File 'lib/valkey/commands/server_commands.rb', line 341

def acl_list
  send_command(RequestType::ACL_LIST)
end

#acl_load ⇒ String

Reload the ACL rules from the configured ACL file.

Examples:

Reload ACL from file

valkey.acl_load
  # => "OK"

Returns:

  • (String) —

    "OK"

See Also:



354
355
356
 
# File 'lib/valkey/commands/server_commands.rb', line 354

def acl_load
  send_command(RequestType::ACL_LOAD)
end

#acl_log(count_or_reset = nil) ⇒ Array<Hash>, String

List latest ACL security events.

Examples:

Get recent ACL log entries

valkey.acl_log
  # => [{"count" => 1, "reason" => "auth", ...}, ...]

Get specific number of log entries

valkey.acl_log(10)
  # => [...]

Reset the ACL log

valkey.acl_log("RESET")
  # => "OK"

Parameters:

  • count_or_reset (Integer, String) (defaults to: nil) —

    number of entries or "RESET" to clear the log

Returns:

  • (Array<Hash>, String) —

    array of log entries, or "OK" if reset

See Also:



374
375
376
377
 
# File 'lib/valkey/commands/server_commands.rb', line 374

def acl_log(count_or_reset = nil)
  args = count_or_reset ? [count_or_reset] : []
  send_command(RequestType::ACL_LOG, args)
end

#acl_save ⇒ String

Save the current ACL rules to the configured ACL file.

Examples:

Save ACL to file

valkey.acl_save
  # => "OK"

Returns:

  • (String) —

    "OK"

See Also:



388
389
390
 
# File 'lib/valkey/commands/server_commands.rb', line 388

def acl_save
  send_command(RequestType::ACL_SAVE)
end

#acl_setuser(username, *rules) ⇒ String

Modify or create ACL rules for a user.

Examples:

Create a user with password

valkey.acl_setuser("alice", "on", ">password", "~*", "+@all")
  # => "OK"

Create a read-only user

valkey.acl_setuser("bob", "on", ">pass123", "~*", "+@read")
  # => "OK"

Disable a user

valkey.acl_setuser("alice", "off")
  # => "OK"

Parameters:

  • username (String) —

    the username to modify or create

  • rules (Array<String>) —

    ACL rules to apply

Returns:

  • (String) —

    "OK"

See Also:



409
410
411
412
 
# File 'lib/valkey/commands/server_commands.rb', line 409

def acl_setuser(username, *rules)
  command_args = [username] + rules
  send_command(RequestType::ACL_SET_USER, command_args)
end

#acl_users ⇒ Array<String>

List all configured ACL users.

Examples:

List all users

valkey.acl_users
  # => ["default", "alice", "bob"]

Returns:

  • (Array<String>) —

    array of usernames

See Also:



423
424
425
 
# File 'lib/valkey/commands/server_commands.rb', line 423

def acl_users
  send_command(RequestType::ACL_USERS)
end

#acl_whoami ⇒ String

Return the username of the current connection.

Examples:

Get current username

valkey.acl_whoami
  # => "default"

Returns:

  • (String) —

    the current username

See Also:



436
437
438
 
# File 'lib/valkey/commands/server_commands.rb', line 436

def acl_whoami
  send_command(RequestType::ACL_WHOAMI)
end

#bgrewriteaof(route: nil) ⇒ String

Asynchronously rewrite the append-only file.

Parameters:

  • route (Valkey::Route, nil) (defaults to: nil) —

    cluster routing. When routed, may return a Hash of node => value.

Returns:

  • (String) 


14
15
16
 
# File 'lib/valkey/commands/server_commands.rb', line 14

def bgrewriteaof(route: nil)
  send_command(RequestType::BG_REWRITE_AOF, [], route: route)
end

#bgsave(route: nil) ⇒ String

Asynchronously save the dataset to disk.

Parameters:

  • route (Valkey::Route, nil) (defaults to: nil) —

    cluster routing. When routed, may return a Hash of node => value.

Returns:

  • (String) 


22
23
24
 
# File 'lib/valkey/commands/server_commands.rb', line 22

def bgsave(route: nil)
  send_command(RequestType::BG_SAVE, [], route: route)
end

#command(subcommand, *args) ⇒ Object

Send a generic COMMAND subcommand.

Examples:

command(:count)                    # => 234
command(:list)                     # => ["GET", "SET", ...]
command(:info, "GET", "SET")       # => [[...], [...]]

Parameters:

  • subcommand (Symbol, String) —

    The COMMAND subcommand to run, e.g. :count, :docs, :info, :list

  • args (Array) —

    Arguments for the subcommand

Returns:

  • (Object) —

    Depends on subcommand



843
844
845
 
# File 'lib/valkey/commands/server_commands.rb', line 843

def command(subcommand, *args)
  send("command_#{subcommand.to_s.downcase}", *args)
end

#command_ ⇒ Array

Return details about every Redis command.

Examples:

valkey.command
  # => [["GET", 2, ["readonly", "fast"], 1, 1, 1], ...]

Returns:

  • (Array) —

    array of command information arrays

See Also:



856
857
858
 
# File 'lib/valkey/commands/server_commands.rb', line 856

def command_
  send_command(RequestType::COMMAND_)
end

#command_count ⇒ Integer

Return the total number of commands in the server.

Examples:

valkey.command_count
  # => 234

Returns:

  • (Integer) —

    total number of commands

See Also:



869
870
871
 
# File 'lib/valkey/commands/server_commands.rb', line 869

def command_count
  send_command(RequestType::COMMAND_COUNT)
end

#command_docs(*commands) ⇒ Array

Return documentary information about one or more commands.

Examples:

Get docs for specific commands

valkey.command_docs("GET", "SET")
  # => [{"summary" => "...", "since" => "1.0.0", ...}, ...]

Get docs for all commands

valkey.command_docs
  # => [{"summary" => "...", ...}, ...]

Parameters:

  • commands (Array<String>) —

    command names to get documentation for

Returns:

  • (Array) —

    array of command documentation hashes

See Also:



886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
 
# File 'lib/valkey/commands/server_commands.rb', line 886

def command_docs(*commands)
  args = commands.empty? ? [] : commands
  send_command(RequestType::COMMAND_DOCS, args) do |reply|
    if reply.is_a?(Array)
      # Convert array of arrays to array of hashes
      reply.map do |cmd_doc|
        if cmd_doc.is_a?(Array)
          Hash[*cmd_doc]
        else
          cmd_doc
        end
      end
    else
      reply
    end
  end
end

#command_get_keys(*command) ⇒ Array

Extract keys from a full Redis command.

Examples:

valkey.command_get_keys("GET", "mykey")
  # => [0]
valkey.command_get_keys("MSET", "key1", "val1", "key2", "val2")
  # => [0, 2]

Parameters:

  • command (String, Array<String>) —

    the command and its arguments

Returns:

  • (Array) —

    array of key positions

See Also:



916
917
918
 
# File 'lib/valkey/commands/server_commands.rb', line 916

def command_get_keys(*command)
  send_command(RequestType::COMMAND_GET_KEYS, command)
end

#command_get_keys_and_flags(*command) ⇒ Array

Extract keys and their flags from a full Redis command.

Examples:

valkey.command_get_keys_and_flags("GET", "mykey")
  # => [[0, ["RW", "access"]], ...]

Parameters:

  • command (String, Array<String>) —

    the command and its arguments

Returns:

  • (Array) —

    array of [key_position, flags] pairs

See Also:



930
931
932
 
# File 'lib/valkey/commands/server_commands.rb', line 930

def command_get_keys_and_flags(*command)
  send_command(RequestType::COMMAND_GET_KEYS_AND_FLAGS, command)
end

#command_info(*commands) ⇒ Array

Return information about one or more commands.

Examples:

Get info for specific commands

valkey.command_info("GET", "SET")
  # => [[...], [...]]

Get info for all commands

valkey.command_info
  # => [[...], ...]

Parameters:

  • commands (Array<String>) —

    command names to get information for

Returns:

  • (Array) —

    array of command information arrays

See Also:



947
948
949
950
 
# File 'lib/valkey/commands/server_commands.rb', line 947

def command_info(*commands)
  args = commands.empty? ? [] : commands
  send_command(RequestType::COMMAND_INFO, args)
end

#command_list(filterby: nil, aclcat: nil, pattern: nil) ⇒ Array<String>

Return an array of command names.

Examples:

Get all commands

valkey.command_list
  # => ["GET", "SET", "DEL", ...]

Filter by module with pattern

valkey.command_list(filterby: "json", pattern: "json.*")
  # => ["json.get", "json.set", ...]

Filter by ACL category

valkey.command_list(aclcat: "read")
  # => ["GET", "MGET", ...]

Parameters:

  • options (Hash) —

    optional filters

    • :filterby => String: filter by module name (e.g., "json")
    • :aclcat => String: filter by ACL category
    • :pattern => String: pattern to match (used with filterby)

Returns:

  • (Array<String>) —

    array of command names

See Also:



971
972
973
974
975
976
977
978
979
 
# File 'lib/valkey/commands/server_commands.rb', line 971

def command_list(filterby: nil, aclcat: nil, pattern: nil)
  args = []
  if aclcat
    args << "FILTERBY" << "ACLCAT" << aclcat
  elsif filterby && pattern
    args << "FILTERBY" << filterby << pattern
  end
  send_command(RequestType::COMMAND_LIST, args)
end

#config(action, *args) ⇒ String, Hash

Get or set server configuration parameters.

Parameters:

  • action (Symbol) —

    e.g. :get, :set, :resetstat

Returns:

  • (String, Hash) —

    string reply, or hash when retrieving more than one property with CONFIG GET



31
32
33
 
# File 'lib/valkey/commands/server_commands.rb', line 31

def config(action, *args)
  send("config_#{action.to_s.downcase}", *args)
end

#config_get(*args, route: nil) ⇒ Hash

Get server configuration parameters.

Sends the CONFIG GET command with the given arguments.

Examples:

Get all configuration parameters

config_get('*')

Get a specific parameter

config_get('maxmemory')

Parameters:

  • args (Array<String>) —

    Configuration parameters to get

  • route (Valkey::Route, nil) (defaults to: nil) —

    cluster routing. Default is a single random node. A multi-node route returns a Hash of "host:port" => { parameter => value }.

Returns:

  • (Hash) —

    a flat { parameter => value } Hash, or a per-node Hash under a multi-node route.



50
51
52
53
54
55
56
57
58
 
# File 'lib/valkey/commands/server_commands.rb', line 50

def config_get(*args, route: nil)
  send_command(RequestType::CONFIG_GET, args, route: route) do |reply|
    if reply.is_a?(Array)
      Hash[*reply]
    else
      reply
    end
  end
end

#config_resetstat(route: nil) ⇒ String

Reset the server's statistics.

Sends the CONFIG RESETSTAT command.

Examples:

config_resetstat

Parameters:

  • route (Valkey::Route, nil) (defaults to: nil) —

    cluster routing.

Returns:

  • (String) —

    Returns "OK" if successful



83
84
85
 
# File 'lib/valkey/commands/server_commands.rb', line 83

def config_resetstat(route: nil)
  send_command(RequestType::CONFIG_RESET_STAT, [], route: route)
end

#config_rewrite(route: nil) ⇒ String

Rewrite the server configuration file.

Sends the CONFIG REWRITE command.

Examples:

config_rewrite

Parameters:

  • route (Valkey::Route, nil) (defaults to: nil) —

    cluster routing.

Returns:

  • (String) —

    Returns "OK" if successful



96
97
98
 
# File 'lib/valkey/commands/server_commands.rb', line 96

def config_rewrite(route: nil)
  send_command(RequestType::CONFIG_REWRITE, [], route: route)
end

#config_set(*args, route: nil) ⇒ String

Set server configuration parameters.

Sends the CONFIG SET command with the given key-value pairs.

Examples:

Set maxmemory to 100mb

config_set('maxmemory', '100mb')

Parameters:

  • args (Array<String>) —

    Key-value pairs to set configuration

  • route (Valkey::Route, nil) (defaults to: nil) —

    cluster routing.

Returns:

  • (String) —

    Returns "OK" if successful



70
71
72
 
# File 'lib/valkey/commands/server_commands.rb', line 70

def config_set(*args, route: nil)
  send_command(RequestType::CONFIG_SET, args, route: route)
end

#dbsize(route: nil) ⇒ Integer

Return the number of keys in the selected database.

Parameters:

  • route (Valkey::Route, nil) (defaults to: nil) —

    cluster routing. Multi-node routes return the aggregated sum across nodes, not a per-node Hash.

Returns:

  • (Integer) 


105
106
107
 
# File 'lib/valkey/commands/server_commands.rb', line 105

def dbsize(route: nil)
  send_command(RequestType::DB_SIZE, [], route: route)
end

#failover(to: nil, force: false, abort: false, timeout: nil) ⇒ String

Perform a manual failover of a master to one of its replicas.

Examples:

Perform a failover

valkey.failover
  # => "OK"

Failover to a specific replica

valkey.failover(to: "127.0.0.1 6380")
  # => "OK"

Force failover

valkey.failover(force: true)
  # => "OK"

Abort failover

valkey.failover(abort: true)
  # => "OK"

Failover with timeout

valkey.failover(timeout: 5000)
  # => "OK"

Parameters:

  • options (Hash) —

    optional parameters

    • :to => String: host and port of the replica to promote (e.g., "host port")
    • :force => Boolean: force failover even if master is reachable
    • :abort => Boolean: abort an ongoing failover
    • :timeout => Integer: timeout in milliseconds

Returns:

  • (String) —

    "OK"

See Also:



514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
 
# File 'lib/valkey/commands/server_commands.rb', line 514

def failover(to: nil, force: false, abort: false, timeout: nil)
  args = []
  if abort
    # ABORT is mutually exclusive: cancels an ongoing failover and
    # ignores any other arguments (matches the core GLIDE clients).
    args << "ABORT"
  else
    if to
      host, port = to.split
      args << "TO" << host << port
      # FORCE is only valid in combination with TO.
      args << "FORCE" if force
    end
    args << "TIMEOUT" << timeout.to_s if timeout
  end
  send_command(RequestType::FAIL_OVER, args)
end

#flushall(options = nil, route: nil) ⇒ String

Remove all keys from all databases.

Parameters:

  • options (Hash) (defaults to: nil) —
    • :async => Boolean: async flush (default: false)
  • route (Valkey::Route, nil) (defaults to: nil) —

    cluster routing.

Returns:

  • (String) —

    OK



115
116
117
118
119
120
121
 
# File 'lib/valkey/commands/server_commands.rb', line 115

def flushall(options = nil, route: nil)
  if options && options[:async]
    send_command(RequestType::FLUSH_ALL, ["async"], route: route)
  else
    send_command(RequestType::FLUSH_ALL, [], route: route)
  end
end

#flushdb(options = nil, route: nil) ⇒ String

Remove all keys from the current database.

Parameters:

  • options (Hash) (defaults to: nil) —
    • :async => Boolean: async flush (default: false)
  • route (Valkey::Route, nil) (defaults to: nil) —

    cluster routing.

Returns:

  • (String) —

    OK



129
130
131
132
133
134
135
 
# File 'lib/valkey/commands/server_commands.rb', line 129

def flushdb(options = nil, route: nil)
  if options && options[:async]
    send_command(RequestType::FLUSH_DB, ["async"], route: route)
  else
    send_command(RequestType::FLUSH_DB, [], route: route)
  end
end

#info(cmd = nil, route: nil) ⇒ Hash

Get information and statistics about the server.

Parameters:

  • cmd (String, Symbol, nil) (defaults to: nil) —

    section name (e.g. "commandstats")

  • route (Valkey::Route, nil) (defaults to: nil) —

    cluster routing. On cluster the default is all primaries, so the reply is a per-node Hash even with no route. Standalone (or a single-node route) returns a flat Hash.

Returns:

  • (Hash) —

    a flat { field => value } Hash, or a per-node { "host:port" => { field => value } } Hash under a multi-node route.



145
146
147
148
149
150
151
152
153
154
155
 
# File 'lib/valkey/commands/server_commands.rb', line 145

def info(cmd = nil, route: nil)
  send_command(RequestType::INFO, [cmd].compact, route: route) do |reply|
    if reply.is_a?(Hash)
      reply.transform_values { |v| parse_info_reply(v, cmd) }
    elsif reply.is_a?(String)
      parse_info_reply(reply, cmd)
    else
      reply
    end
  end
end

#lastsave(route: nil) ⇒ Integer

Get the UNIX time stamp of the last successful save to disk.

Parameters:

  • route (Valkey::Route, nil) (defaults to: nil) —

    cluster routing. When routed, may return a Hash of node => value.

Returns:

  • (Integer) 


178
179
180
 
# File 'lib/valkey/commands/server_commands.rb', line 178

def lastsave(route: nil)
  send_command(RequestType::LAST_SAVE, [], route: route)
end

#latency_doctor ⇒ String

Return a human-readable latency analysis report.

Examples:

valkey.latency_doctor
  # => "Dave, I observed latency events in this Redis instance..."

Returns:

  • (String) —

    human-readable latency analysis

See Also:



672
673
674
 
# File 'lib/valkey/commands/server_commands.rb', line 672

def latency_doctor
  send_command(RequestType::LATENCY_DOCTOR)
end

#latency_graph(event) ⇒ String

Return an ASCII-art graph of the latency samples for the specified event.

Examples:

valkey.latency_graph("command")
  # => "command - high 500 ms, low 501 ms (all time high 500 ms)\n..."

Parameters:

  • event (String) —

    the event name to graph

Returns:

  • (String) —

    ASCII-art graph of latency samples

See Also:



686
687
688
 
# File 'lib/valkey/commands/server_commands.rb', line 686

def latency_graph(event)
  send_command(RequestType::LATENCY_GRAPH, [event])
end

#latency_histogram(*commands) ⇒ Array

Return a latency histogram for the specified commands.

Examples:

Get histogram for all commands

valkey.latency_histogram
  # => [["SET", [["0-1", 100], ["2-3", 50], ...]], ...]

Get histogram for specific commands

valkey.latency_histogram("SET", "GET")
  # => [["SET", [["0-1", 100], ...]], ["GET", [["0-1", 200], ...]]]

Parameters:

  • commands (Array<String>) —

    optional command names to get histograms for

Returns:

  • (Array) —

    array of latency histogram entries

See Also:



703
704
705
706
 
# File 'lib/valkey/commands/server_commands.rb', line 703

def latency_histogram(*commands)
  args = commands.empty? ? [] : commands
  send_command(RequestType::LATENCY_HISTOGRAM, args)
end

#latency_history(event) ⇒ Array

Return the latency time series for the specified event.

Examples:

valkey.latency_history("command")
  # => [[1234567890, 100], [1234567891, 150], ...]

Parameters:

  • event (String) —

    the event name to get history for

Returns:

  • (Array) —

    array of [timestamp, latency] pairs

See Also:



718
719
720
 
# File 'lib/valkey/commands/server_commands.rb', line 718

def latency_history(event)
  send_command(RequestType::LATENCY_HISTORY, [event])
end

#latency_latest ⇒ Array

Return the latest latency samples for all events.

Examples:

valkey.latency_latest
  # => [["command", 1234567890, 100, 200], ["fast-command", 1234567891, 50, 100]]

Returns:

  • (Array) —

    array of event information arrays Each entry is [event_name, timestamp, latest_latency, max_latency]

See Also:



732
733
734
 
# File 'lib/valkey/commands/server_commands.rb', line 732

def latency_latest
  send_command(RequestType::LATENCY_LATEST)
end

#latency_reset(*events) ⇒ Integer

Reset latency data for all events or specific events.

Examples:

Reset all latency data

valkey.latency_reset
  # => 3

Reset specific events

valkey.latency_reset("command", "fast-command")
  # => 2

Parameters:

  • events (Array<String>) —

    optional event names to reset If no events are specified, resets all latency data

Returns:

  • (Integer) —

    number of events reset

See Also:



750
751
752
753
 
# File 'lib/valkey/commands/server_commands.rb', line 750

def latency_reset(*events)
  args = events.empty? ? [] : events
  send_command(RequestType::LATENCY_RESET, args)
end

#lolwut(version = nil, route: nil) ⇒ String

Display some computer art and the Valkey version.

Examples:

valkey.lolwut
  # => "Valkey ver. 7.0.0\n..."

With version

valkey.lolwut(5)
  # => "Valkey ver. 7.0.0\n..."

Parameters:

  • version (Integer, nil) (defaults to: nil) —

    optional version number for different art

  • route (Valkey::Route, nil) (defaults to: nil) —

    cluster routing. When routed, may return a Hash of node => value.

Returns:

  • (String) —

    ASCII art and version information

See Also:



546
547
548
549
 
# File 'lib/valkey/commands/server_commands.rb', line 546

def lolwut(version = nil, route: nil)
  args = version ? ["VERSION", version.to_s] : []
  send_command(RequestType::LOLWUT, args, route: route)
end

#memory_doctor ⇒ String

Return a human-readable memory problems report.

Examples:

valkey.memory_doctor
  # => "Hi Sam, this is the Valkey memory doctor..."

Returns:

  • (String) —

    human-readable memory analysis report

See Also:



764
765
766
 
# File 'lib/valkey/commands/server_commands.rb', line 764

def memory_doctor
  send_command(RequestType::MEMORY_DOCTOR)
end

#memory_malloc_stats ⇒ String

Return memory allocator statistics.

Examples:

valkey.memory_malloc_stats
  # => "___ Begin jemalloc statistics ___..."

Returns:

  • (String) —

    memory allocator statistics

See Also:



777
778
779
 
# File 'lib/valkey/commands/server_commands.rb', line 777

def memory_malloc_stats
  send_command(RequestType::MEMORY_MALLOC_STATS)
end

#memory_purge ⇒ String

Ask the allocator to release memory back to the operating system.

Examples:

valkey.memory_purge
  # => "OK"

Returns:

  • (String) —

    "OK"

See Also:



790
791
792
 
# File 'lib/valkey/commands/server_commands.rb', line 790

def memory_purge
  send_command(RequestType::MEMORY_PURGE)
end

#memory_stats ⇒ Hash

Return memory usage statistics.

Examples:

valkey.memory_stats
  # => {"peak.allocated" => "1048576", "total.allocated" => "524288", ...}

Returns:

  • (Hash) —

    memory usage statistics

See Also:



803
804
805
806
807
808
809
810
811
 
# File 'lib/valkey/commands/server_commands.rb', line 803

def memory_stats
  send_command(RequestType::MEMORY_STATS) do |reply|
    if reply.is_a?(Array)
      Hash[*reply]
    else
      reply
    end
  end
end

#memory_usage(key, samples: nil) ⇒ Integer?

Return the memory usage in bytes of a key and its value.

Examples:

Get memory usage for a key

valkey.memory_usage("mykey")
  # => 1024

Get memory usage with custom samples

valkey.memory_usage("mykey", samples: 10)
  # => 2048

Parameters:

  • key (String) —

    the key to check

  • options (Hash) —

    optional parameters

    • :samples => Integer: number of samples for nested data structures (default: 5)

Returns:

  • (Integer, nil) —

    memory usage in bytes, or nil if key doesn't exist

See Also:



828
829
830
831
832
 
# File 'lib/valkey/commands/server_commands.rb', line 828

def memory_usage(key, samples: nil)
  args = [key]
  args << "SAMPLES" << samples.to_s if samples
  send_command(RequestType::MEMORY_USAGE, args)
end

#psync(replication_id, offset) ⇒ String

Internal command used for replication (partial resynchronization).

Examples:

valkey.psync("?", -1)
  # => "+FULLRESYNC ..."

Parameters:

  • replication_id (String) —

    the replication ID

  • offset (Integer) —

    the replication offset

Returns:

  • (String) —

    replication stream data

See Also:



562
563
564
 
# File 'lib/valkey/commands/server_commands.rb', line 562

def psync(replication_id, offset)
  send_command(RequestType::PSYNC, [replication_id, offset.to_s])
end

#replconf(*args) ⇒ String, Array

Internal command used for replication configuration.

Examples:

Set listening port

valkey.replconf("listening-port", "6380")
  # => "OK"

Send ACK

valkey.replconf("ACK", "1000")
  # => "OK"

Parameters:

  • args (Array<String>) —

    configuration arguments

Returns:

  • (String, Array) —

    depends on the configuration command

See Also:



579
580
581
 
# File 'lib/valkey/commands/server_commands.rb', line 579

def replconf(*args)
  send_command(RequestType::REPL_CONF, args)
end

#replicaof(host, port) ⇒ String

Make the server a replica of another instance, or promote it as master.

Examples:

Make server a replica

valkey.replicaof("127.0.0.1", 6379)
  # => "OK"

Promote to master

valkey.replicaof("NO", "ONE")
  # => "OK"

Parameters:

  • host (String) —

    the master host (use "NO" with "ONE" to promote to master)

  • port (String, Integer) —

    the master port (use "ONE" with "NO" to promote to master)

Returns:

  • (String) —

    "OK"

See Also:



597
598
599
 
# File 'lib/valkey/commands/server_commands.rb', line 597

def replicaof(host, port)
  send_command(RequestType::REPLICA_OF, [host, port.to_s])
end

#restore_asking(key, ttl, serialized_value, replace: false, absttl: false, idletime: nil, freq: nil) ⇒ String

Internal command used in cluster mode for key migration with ASKING flag.

Examples:

Restore a key with ASKING

valkey.restore_asking("mykey", 0, serialized_data)
  # => "OK"

Restore with replace

valkey.restore_asking("mykey", 0, serialized_data, replace: true)
  # => "OK"

Parameters:

  • key (String) —

    the key to restore

  • ttl (Integer) —

    time to live in milliseconds (0 for no expiry)

  • serialized_value (String) —

    the serialized value from DUMP

  • options (Hash) —

    optional parameters

    • :replace => Boolean: replace existing key
    • :absttl => Boolean: ttl is an absolute timestamp
    • :idletime => Integer: set idle time in seconds
    • :freq => Integer: set LFU frequency

Returns:

  • (String) —

    "OK"

See Also:



621
622
623
624
625
626
627
628
 
# File 'lib/valkey/commands/server_commands.rb', line 621

def restore_asking(key, ttl, serialized_value, replace: false, absttl: false, idletime: nil, freq: nil)
  args = [key, ttl.to_s, serialized_value]
  args << "REPLACE" if replace
  args << "ABSTTL" if absttl
  args << "IDLETIME" << idletime.to_s if idletime
  args << "FREQ" << freq.to_s if freq
  send_command(RequestType::RESTORE_ASKING, args)
end

#role ⇒ Array

Return the role of the instance in the context of replication.

Examples:

Get role on master

valkey.role
  # => ["master", 3129659, [["127.0.0.1", "6380", "3129659"]]]

Get role on replica

valkey.role
  # => ["slave", "127.0.0.1", 6379, "connected", 3129659]

Returns:

  • (Array) —

    role information

    • For master: ["master", replication_offset, [replica1, replica2, ...]]
    • For replica: ["slave", master_host, master_port, replication_state, replication_offset]

See Also:



644
645
646
 
# File 'lib/valkey/commands/server_commands.rb', line 644

def role
  send_command(RequestType::ROLE)
end

#save(route: nil) ⇒ String

Synchronously save the dataset to disk.

Parameters:

  • route (Valkey::Route, nil) (defaults to: nil) —

    cluster routing.

Returns:

  • (String) 


186
187
188
 
# File 'lib/valkey/commands/server_commands.rb', line 186

def save(route: nil)
  send_command(RequestType::SAVE, [], route: route)
end

#slaveof(host, port) ⇒ Object

Make the server a slave of another instance, or promote it as master.



191
192
193
 
# File 'lib/valkey/commands/server_commands.rb', line 191

def slaveof(host, port)
  send_command(RequestType::SLAVE_OF, [host, port])
end

#slowlog(subcommand, length = nil) ⇒ Array<Array>, ...

Interact with the slowlog (get, len, reset)

Examples:

Get the number of entries in the slowlog

valkey.slowlog(:len) # => 0

Get the most recent entries

valkey.slowlog(:get, 2)

Parameters:

  • subcommand (String, Symbol) —

    one of get, len, reset

  • length (Integer) (defaults to: nil) —

    maximum number of entries to return (get only)

Returns:

  • (Array<Array>, Integer, String) —

    depends on subcommand

Raises:

  • (ArgumentError) —

    if the subcommand is not one of get, len, reset

See Also:



208
209
210
211
212
213
214
215
216
217
218
219
220
221
 
# File 'lib/valkey/commands/server_commands.rb', line 208

def slowlog(subcommand, length = nil)
  case subcommand.to_s.downcase
  when "get"
    args = []
    args << Integer(length) if length
    send_command(RequestType::SLOWLOG_GET, args)
  when "len"
    send_command(RequestType::SLOWLOG_LEN)
  when "reset"
    send_command(RequestType::SLOWLOG_RESET)
  else
    raise ArgumentError, "Unknown SLOWLOG subcommand: #{subcommand}"
  end
end

#swapdb(index1, index2) ⇒ String

Swap two databases.

Examples:

Swap database 0 and 1

valkey.swapdb(0, 1)
  # => "OK"

Parameters:

  • index1 (Integer) —

    first database index

  • index2 (Integer) —

    second database index

Returns:

  • (String) —

    "OK"

See Also:



659
660
661
 
# File 'lib/valkey/commands/server_commands.rb', line 659

def swapdb(index1, index2)
  send_command(RequestType::SWAP_DB, [index1.to_s, index2.to_s])
end

#sync ⇒ Object

Internal command used for replication.



224
225
226
 
# File 'lib/valkey/commands/server_commands.rb', line 224

def sync
  send_command(RequestType::SYNC)
end

#time(route: nil) ⇒ Array<String>, Hash{String => Array<String>}

Return the server time.

Examples:

r.time # => ["1333093196", "606806"]

Parameters:

  • route (Valkey::Route, nil) (defaults to: nil) —

    cluster routing. Default is a single random node. A multi-node route returns a Hash of "host:port" => [seconds, microseconds].

Returns:

  • (Array<String>, Hash{String => Array<String>}) —

    a two-element array of seconds since UNIX epoch and microseconds in the current second (both as strings), or a per-node Hash under a multi-node route. Call .map(&:to_i) on the array elements for arithmetic.



239
240
241
 
# File 'lib/valkey/commands/server_commands.rb', line 239

def time(route: nil)
  send_command(RequestType::TIME, [], route: route)
end