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



469
470
471
472
 
# File 'lib/valkey/commands/server_commands.rb', line 469

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:



244
245
246
247
 
# File 'lib/valkey/commands/server_commands.rb', line 244

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:



262
263
264
 
# File 'lib/valkey/commands/server_commands.rb', line 262

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:



281
282
283
284
 
# File 'lib/valkey/commands/server_commands.rb', line 281

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:



299
300
301
302
 
# File 'lib/valkey/commands/server_commands.rb', line 299

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:



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

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:



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

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:



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

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:



360
361
362
363
 
# File 'lib/valkey/commands/server_commands.rb', line 360

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:



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

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:



395
396
397
398
 
# File 'lib/valkey/commands/server_commands.rb', line 395

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:



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

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:



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

def acl_whoami
  send_command(RequestType::ACL_WHOAMI)
end

#bgrewriteaof ⇒ String

Asynchronously rewrite the append-only file.

Returns:

  • (String) —

    ‘OK`



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

def bgrewriteaof
  send_command(RequestType::BG_REWRITE_AOF)
end

#bgsave ⇒ String

Asynchronously save the dataset to disk.

Returns:

  • (String) —

    ‘OK`



20
21
22
 
# File 'lib/valkey/commands/server_commands.rb', line 20

def bgsave
  send_command(RequestType::BG_SAVE)
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



822
823
824
 
# File 'lib/valkey/commands/server_commands.rb', line 822

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:



835
836
837
 
# File 'lib/valkey/commands/server_commands.rb', line 835

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:



848
849
850
 
# File 'lib/valkey/commands/server_commands.rb', line 848

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:



865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
 
# File 'lib/valkey/commands/server_commands.rb', line 865

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:



895
896
897
 
# File 'lib/valkey/commands/server_commands.rb', line 895

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:



909
910
911
 
# File 'lib/valkey/commands/server_commands.rb', line 909

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:



926
927
928
929
 
# File 'lib/valkey/commands/server_commands.rb', line 926

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:



950
951
952
953
954
955
956
957
958
 
# File 'lib/valkey/commands/server_commands.rb', line 950

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`



29
30
31
 
# File 'lib/valkey/commands/server_commands.rb', line 29

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

#config_get(*args) ⇒ Hash, String

Note:

Returns a Hash with parameter names as keys and values as values when multiple params requested.

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

Returns:

  • (Hash, String) —

    Returns a Hash if multiple parameters are requested, otherwise returns a String with the value.



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

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

#config_resetstat ⇒ String

Reset the server’s statistics.

Sends the CONFIG RESETSTAT command.

Examples:

config_resetstat

Returns:

  • (String) —

    Returns “OK” if successful



79
80
81
 
# File 'lib/valkey/commands/server_commands.rb', line 79

def config_resetstat
  send_command(RequestType::CONFIG_RESET_STAT)
end

#config_rewrite ⇒ String

Rewrite the server configuration file.

Sends the CONFIG REWRITE command.

Examples:

config_rewrite

Returns:

  • (String) —

    Returns “OK” if successful



91
92
93
 
# File 'lib/valkey/commands/server_commands.rb', line 91

def config_rewrite
  send_command(RequestType::CONFIG_REWRITE)
end

#config_set(*args) ⇒ 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

Returns:

  • (String) —

    Returns “OK” if successful



67
68
69
 
# File 'lib/valkey/commands/server_commands.rb', line 67

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

#dbsize ⇒ Integer

Return the number of keys in the selected database.

Returns:

  • (Integer) 


98
99
100
 
# File 'lib/valkey/commands/server_commands.rb', line 98

def dbsize
  send_command(RequestType::DB_SIZE)
end

#debug(*args) ⇒ Object

RequestType::DEBUG not exist



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

def debug(*args)
  send_command(RequestType::DEBUG, args)
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:



500
501
502
503
504
505
506
507
508
509
510
 
# File 'lib/valkey/commands/server_commands.rb', line 500

def failover(to: nil, force: false, abort: false, timeout: nil)
  args = []
  if to
    host, port = to.split
    args << "TO" << host << port
  end
  args << "FORCE" if force
  args << "ABORT" if abort
  args << "TIMEOUT" << timeout.to_s if timeout
  send_command(RequestType::FAIL_OVER, args)
end

#flushall(options = nil) ⇒ String

Remove all keys from all databases.

Parameters:

  • options (Hash) (defaults to: nil) —

    • ‘:async => Boolean`: async flush (default: false)

Returns:

  • (String) —

    ‘OK`



107
108
109
110
111
112
113
 
# File 'lib/valkey/commands/server_commands.rb', line 107

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

#flushdb(options = nil) ⇒ String

Remove all keys from the current database.

Parameters:

  • options (Hash) (defaults to: nil) —

    • ‘:async => Boolean`: async flush (default: false)

Returns:

  • (String) —

    ‘OK`



120
121
122
123
124
125
126
 
# File 'lib/valkey/commands/server_commands.rb', line 120

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

#info(cmd = nil) ⇒ Hash<String, String>

Get information and statistics about the server.

Parameters:

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

    e.g. “commandstats”

Returns:

  • (Hash<String, String>) 


132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
# File 'lib/valkey/commands/server_commands.rb', line 132

def info(cmd = nil)
  send_command(RequestType::INFO, [cmd].compact) do |reply|
    if reply.is_a?(String)
      reply = Utils::HashifyInfo.call(reply)

      if cmd && cmd.to_s == "commandstats"
        # Extract nested hashes for INFO COMMANDSTATS
        reply = reply.to_h do |k, v|
          v = v.split(",").map { |e| e.split("=") }
          [k[/^cmdstat_(.*)$/, 1], v.to_h]
        end
      end
    end

    reply
  end
end

#lastsave ⇒ Integer

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

Returns:

  • (Integer) 


153
154
155
 
# File 'lib/valkey/commands/server_commands.rb', line 153

def lastsave
  send_command(RequestType::LAST_SAVE)
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:



651
652
653
 
# File 'lib/valkey/commands/server_commands.rb', line 651

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:



665
666
667
 
# File 'lib/valkey/commands/server_commands.rb', line 665

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:



682
683
684
685
 
# File 'lib/valkey/commands/server_commands.rb', line 682

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:



697
698
699
 
# File 'lib/valkey/commands/server_commands.rb', line 697

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:



711
712
713
 
# File 'lib/valkey/commands/server_commands.rb', line 711

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:



729
730
731
732
 
# File 'lib/valkey/commands/server_commands.rb', line 729

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

#lolwut(version = 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) (defaults to: nil) —

    optional version number for different art

Returns:

  • (String) —

    ASCII art and version information

See Also:



525
526
527
528
 
# File 'lib/valkey/commands/server_commands.rb', line 525

def lolwut(version = nil)
  args = version ? ["VERSION", version.to_s] : []
  send_command(RequestType::LOLWUT, args)
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:



743
744
745
 
# File 'lib/valkey/commands/server_commands.rb', line 743

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:



756
757
758
 
# File 'lib/valkey/commands/server_commands.rb', line 756

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:



769
770
771
 
# File 'lib/valkey/commands/server_commands.rb', line 769

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:



782
783
784
785
786
787
788
789
790
 
# File 'lib/valkey/commands/server_commands.rb', line 782

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:



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

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

#monitor {|line| ... } ⇒ Object

Listen for all requests received by the server in real time.

There is no way to interrupt this command.

Yields:

  • a block to be called for every line of output

Yield Parameters:

  • line (String) —

    timestamp and command that was executed



163
164
165
166
167
168
169
170
171
 
# File 'lib/valkey/commands/server_commands.rb', line 163

def monitor
  synchronize do |client|
    client = client.pubsub
    client.call_v([:monitor])
    loop do
      yield client.next_event
    end
  end
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:



541
542
543
 
# File 'lib/valkey/commands/server_commands.rb', line 541

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:



558
559
560
 
# File 'lib/valkey/commands/server_commands.rb', line 558

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:



576
577
578
 
# File 'lib/valkey/commands/server_commands.rb', line 576

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:



600
601
602
603
604
605
606
607
 
# File 'lib/valkey/commands/server_commands.rb', line 600

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:



623
624
625
 
# File 'lib/valkey/commands/server_commands.rb', line 623

def role
  send_command(RequestType::ROLE)
end

#save ⇒ String

Synchronously save the dataset to disk.

Returns:

  • (String) 


176
177
178
 
# File 'lib/valkey/commands/server_commands.rb', line 176

def save
  send_command(RequestType::SAVE)
end

#shutdown ⇒ Object

Synchronously save the dataset to disk and then shut down the server.



181
182
183
184
185
186
187
188
189
190
 
# File 'lib/valkey/commands/server_commands.rb', line 181

def shutdown
  synchronize do |client|
    client.disable_reconnection do
      client.call_v([:shutdown])
    rescue ConnectionError
      # This means Redis has probably exited.
      nil
    end
  end
end

#slaveof(host, port) ⇒ Object

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



193
194
195
 
# File 'lib/valkey/commands/server_commands.rb', line 193

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

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

Interact with the slowlog (get, len, reset)

Parameters:

  • subcommand (String) —

    e.g. ‘get`, `len`, `reset`

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

    maximum number of entries to return

Returns:

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

    depends on subcommand



202
203
204
205
206
 
# File 'lib/valkey/commands/server_commands.rb', line 202

def slowlog(subcommand, length = nil)
  args = [:slowlog, subcommand]
  args << Integer(length) if length
  send_command(args)
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:



638
639
640
 
# File 'lib/valkey/commands/server_commands.rb', line 638

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

#sync ⇒ Object

Internal command used for replication.



209
210
211
 
# File 'lib/valkey/commands/server_commands.rb', line 209

def sync
  send_command(RequestType::SYNC)
end

#time ⇒ Array<Integer>

Return the server time.

Examples:

r.time # => [ 1333093196, 606806 ]

Returns:

  • (Array<Integer>) —

    tuple of seconds since UNIX epoch and microseconds in the current second



220
221
222
 
# File 'lib/valkey/commands/server_commands.rb', line 220

def time
  send_command(RequestType::TIME)
end