redis 2.6.4 → 2.8.0

package/README.md

@@ -6,7 +6,8 @@ redis - a node.js redis client
 [![Windows Tests](https://img.shields.io/appveyor/ci/BridgeAR/node-redis/master.svg?label=Windows%20Tests)](https://ci.appveyor.com/project/BridgeAR/node-redis/branch/master)
 [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/NodeRedis/node_redis?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
 
-This is a complete and feature rich Redis client for node.js. __It supports all Redis commands__ and focuses on high performance.
+This is a complete and feature rich Redis client for node.js. __It supports all
+Redis commands__ and focuses on high performance.
 
 Install with:
 
@@ -48,13 +49,16 @@ This will display:
         1: hashtest 2
     mjr:~/work/node_redis (master)$
 
-Note that the API is entirely asynchronous. To get data back from the server, you'll need to use a callback.
-From v.2.6 on the API supports camelCase and snake_case and all options / variables / events etc. can be used either way.
-It is recommended to use camelCase as this is the default for the Node.js landscape.
+Note that the API is entirely asynchronous. To get data back from the server,
+you'll need to use a callback. From v.2.6 on the API supports camelCase and
+snake_case and all options / variables / events etc. can be used either way. It
+is recommended to use camelCase as this is the default for the Node.js
+landscape.
 
 ### Promises
 
-You can also use node_redis with promises by promisifying node_redis with [bluebird](https://github.com/petkaantonov/bluebird) as in:
+You can also use node_redis with promises by promisifying node_redis with
+[bluebird](https://github.com/petkaantonov/bluebird) as in:
 
 ```js
 var redis = require('redis');
@@ -100,7 +104,8 @@ client.set("some key", "some val");
 client.set(["some other key", "some val"]);
 ```
 
-If the key is missing, reply will be null. Only if the [Redis Command Reference](http://redis.io/commands) states something else it will not be null.
+If the key is missing, reply will be null. Only if the [Redis Command
+Reference](http://redis.io/commands) states something else it will not be null.
 
 ```js
 client.get("missingkey", function(err, reply) {
@@ -111,8 +116,24 @@ client.get("missingkey", function(err, reply) {
 
 For a list of Redis commands, see [Redis Command Reference](http://redis.io/commands)
 
-Minimal parsing is done on the replies. Commands that return a integer return JavaScript Numbers, arrays return JavaScript Array. `HGETALL` returns an Object keyed by the hash keys. All strings will either be returned as string or as buffer depending on your setting.
-Please be aware that sending null, undefined and Boolean values will result in the value coerced to a string!
+Minimal parsing is done on the replies. Commands that return a integer return
+JavaScript Numbers, arrays return JavaScript Array. `HGETALL` returns an Object
+keyed by the hash keys. All strings will either be returned as string or as
+buffer depending on your setting. Please be aware that sending null, undefined
+and Boolean values will result in the value coerced to a string!
+
+# Redis Commands
+
+This library is a 1 to 1 mapping to [Redis commands](https://redis.io/commands).
+It is not a cache library so please refer to Redis commands page for full usage
+details.
+
+Example setting key to auto expire using [SET command](https://redis.io/commands/set)
+
+```js
+// this key will expire after 10 seconds
+client.set('key', 'value!', 'EX', 10);
+```
 
 # API
 
@@ -122,8 +143,9 @@ Please be aware that sending null, undefined and Boolean values will result in t
 
 ### "ready"
 
-`client` will emit `ready` once a connection is established. Commands issued before the `ready` event are queued,
-then replayed just before this event is emitted.
+`client` will emit `ready` once a connection is established. Commands issued
+before the `ready` event are queued, then replayed just before this event is
+emitted.
 
 ### "connect"
 
@@ -131,13 +153,16 @@ then replayed just before this event is emitted.
 
 ### "reconnecting"
 
-`client` will emit `reconnecting` when trying to reconnect to the Redis server after losing the connection. Listeners
-are passed an object containing `delay` (in ms) and `attempt` (the attempt #) attributes.
+`client` will emit `reconnecting` when trying to reconnect to the Redis server
+after losing the connection. Listeners are passed an object containing `delay`
+(in ms) and `attempt` (the attempt #) attributes.
 
 ### "error"
 
-`client` will emit `error` when encountering an error connecting to the Redis server or when any other in node_redis occurs.
-If you use a command without callback and encounter a ReplyError it is going to be emitted to the error listener.
+`client` will emit `error` when encountering an error connecting to the Redis
+server or when any other in node_redis occurs. If you use a command without
+callback and encounter a ReplyError it is going to be emitted to the error
+listener.
 
 So please attach the error listener to node_redis.
 
@@ -147,33 +172,41 @@ So please attach the error listener to node_redis.
 
 ### "drain" (deprecated)
 
-`client` will emit `drain` when the TCP connection to the Redis server has been buffering, but is now
-writable. This event can be used to stream commands in to Redis and adapt to backpressure.
+`client` will emit `drain` when the TCP connection to the Redis server has been
+buffering, but is now writable. This event can be used to stream commands in to
+Redis and adapt to backpressure.
 
-If the stream is buffering `client.should_buffer` is set to true. Otherwise the variable is always set to false.
-That way you can decide when to reduce your send rate and resume sending commands when you get `drain`.
+If the stream is buffering `client.should_buffer` is set to true. Otherwise the
+variable is always set to false. That way you can decide when to reduce your
+send rate and resume sending commands when you get `drain`.
 
-You can also check the return value of each command as it will also return the backpressure indicator (deprecated).
-If false is returned the stream had to buffer.
+You can also check the return value of each command as it will also return the
+backpressure indicator (deprecated). If false is returned the stream had to
+buffer.
 
 ### "warning"
 
-`client` will emit `warning` when password was set but none is needed and if a deprecated option / function / similar is used.
+`client` will emit `warning` when password was set but none is needed and if a
+deprecated option / function / similar is used.
 
 ### "idle" (deprecated)
 
-`client` will emit `idle` when there are no outstanding commands that are awaiting a response.
+`client` will emit `idle` when there are no outstanding commands that are
+awaiting a response.
 
 ## redis.createClient()
-If you have `redis-server` running on the same machine as node, then the defaults for
-port and host are probably fine and you don't need to supply any arguments. `createClient()` returns a `RedisClient` object. Otherwise, `createClient()` accepts these arguments:
+If you have `redis-server` running on the same machine as node, then the
+defaults for port and host are probably fine and you don't need to supply any
+arguments. `createClient()` returns a `RedisClient` object. Otherwise,
+`createClient()` accepts these arguments:
 
 * `redis.createClient([options])`
 * `redis.createClient(unix_socket[, options])`
 * `redis.createClient(redis_url[, options])`
 * `redis.createClient(port[, host][, options])`
 
-__Tip:__ If the Redis server runs on the same machine as the client consider using unix sockets if possible to increase throughput.
+__Tip:__ If the Redis server runs on the same machine as the client consider
+using unix sockets if possible to increase throughput.
 
 #### `options` object properties
 | Property  | Default   | Description |
@@ -197,7 +230,7 @@ __Tip:__ If the Redis server runs on the same machine as the client consider usi
 | db | null | If set, client will run Redis `select` command on connect. |
 | family | IPv4 | You can force using IPv6 if you set the family to 'IPv6'. See Node.js [net](https://nodejs.org/api/net.html) or [dns](https://nodejs.org/api/dns.html) modules on how to use the family type. |
 | disable_resubscribing | false | If set to `true`, a client won't resubscribe after disconnecting. |
-| rename_commands | null | Passing an object with renamed commands to use instead of the original functions. See the [Redis security topics](http://redis.io/topics/security) for more info. |
+| rename_commands | null | Passing an object with renamed commands to use instead of the original functions. For example, if you renamed the command KEYS to "DO-NOT-USE" then the rename_commands object would be: `{ KEYS : "DO-NOT-USE" }` . See the [Redis security topics](http://redis.io/topics/security) for more info. |
 | tls | null | An object containing options to pass to [tls.connect](http://nodejs.org/api/tls.html#tls_tls_connect_port_host_options_callback) to set up a TLS connection to Redis (if, for example, it is set up to be accessible via a tunnel). |
 | prefix | null | A string used to prefix all used keys (e.g. `namespace:test`). Please be aware that the `keys` command will not be prefixed. The `keys` command has a "pattern" as argument and no key and it would be impossible to determine the existing keys in Redis if this would be prefixed. |
 | retry_strategy | function | A function that receives an options object as parameter including the retry `attempt`, the `total_retry_time` indicating how much time passed since the last time connected, the `error` why the connection was lost and the number of `times_connected` in total. If you return a number from this function, the retry will happen exactly after that time in milliseconds. If you return a non-number, no further retry will happen and all offline commands are flushed with errors. Return an error to return that specific error to all offline commands. Example below. |
@@ -221,18 +254,21 @@ client.quit();
 ```
 
 retry_strategy example
+
 ```js
 var client = redis.createClient({
     retry_strategy: function (options) {
         if (options.error && options.error.code === 'ECONNREFUSED') {
-            // End reconnecting on a specific error and flush all commands with a individual error
+            // End reconnecting on a specific error and flush all commands with
+            // a individual error
             return new Error('The server refused the connection');
         }
         if (options.total_retry_time > 1000 * 60 * 60) {
-            // End reconnecting after a specific timeout and flush all commands with a individual error
+            // End reconnecting after a specific timeout and flush all commands
+            // with a individual error
             return new Error('Retry time exhausted');
         }
-        if (options.times_connected > 10) {
+        if (options.attempt > 10) {
             // End reconnecting with built in error
             return undefined;
         }
@@ -244,11 +280,12 @@ var client = redis.createClient({
 
 ## client.auth(password[, callback])
 
-When connecting to a Redis server that requires authentication, the `AUTH` command must be sent as the
-first command after connecting. This can be tricky to coordinate with reconnections, the ready check,
-etc. To make this easier, `client.auth()` stashes `password` and will send it after each connection,
-including reconnections. `callback` is invoked only once, after the response to the very first
-`AUTH` command sent.
+When connecting to a Redis server that requires authentication, the `AUTH`
+command must be sent as the first command after connecting. This can be tricky
+to coordinate with reconnections, the ready check, etc. To make this easier,
+`client.auth()` stashes `password` and will send it after each connection,
+including reconnections. `callback` is invoked only once, after the response to
+the very first `AUTH` command sent.
 NOTE: Your call to `client.auth()` should not be inside the ready handler. If
 you are doing this wrong, `client` will emit an error that looks
 something like this `Error: Ready check failed: ERR operation not permitted`.
@@ -257,25 +294,34 @@ something like this `Error: Ready check failed: ERR operation not permitted`.
 
 ### stream
 
-The client exposed the used [stream](https://nodejs.org/api/stream.html) in `client.stream` and if the stream or client had to [buffer](https://nodejs.org/api/stream.html#stream_writable_write_chunk_encoding_callback) the command in `client.should_buffer`.
-In combination this can be used to implement backpressure by checking the buffer state before sending a command and listening to the stream [drain](https://nodejs.org/api/stream.html#stream_event_drain) event.
+The client exposed the used [stream](https://nodejs.org/api/stream.html) in
+`client.stream` and if the stream or client had to
+[buffer](https://nodejs.org/api/stream.html#stream_writable_write_chunk_encoding_callback)
+the command in `client.should_buffer`. In combination this can be used to
+implement backpressure by checking the buffer state before sending a command and
+listening to the stream
+[drain](https://nodejs.org/api/stream.html#stream_event_drain) event.
 
 ## client.quit()
 
-This sends the quit command to the redis server and ends cleanly right after all running commands were properly handled.
-If this is called while reconnecting (and therefor no connection to the redis server exists) it is going to end the connection right away instead of
-resulting in further reconnections! All offline commands are going to be flushed with an error in that case.
+This sends the quit command to the redis server and ends cleanly right after all
+running commands were properly handled. If this is called while reconnecting
+(and therefore no connection to the redis server exists) it is going to end the
+connection right away instead of resulting in further reconnections! All offline
+commands are going to be flushed with an error in that case.
 
 ## client.end(flush)
 
-Forcibly close the connection to the Redis server. Note that this does not wait until all replies have been parsed.
-If you want to exit cleanly, call `client.quit()` as mentioned above.
+Forcibly close the connection to the Redis server. Note that this does not wait
+until all replies have been parsed. If you want to exit cleanly, call
+`client.quit()` as mentioned above.
 
-You should set flush to true, if you are not absolutely sure you do not care about any other commands.
-If you set flush to false all still running commands will silently fail.
+You should set flush to true, if you are not absolutely sure you do not care
+about any other commands. If you set flush to false all still running commands
+will silently fail.
 
-This example closes the connection to the Redis server before the replies have been read. You probably don't
-want to do this:
+This example closes the connection to the Redis server before the replies have
+been read. You probably don't want to do this:
 
 ```js
 var redis = require("redis"),
@@ -296,10 +342,19 @@ client.get("foo_rand000000000000", function (err, reply) {
 
 ## Error handling (>= v.2.6)
 
-All redis errors are returned as `ReplyError`.
-All unresolved commands that get rejected due to what ever reason return a `AbortError`.
-As subclass of the `AbortError` a `AggregateError` exists. This is emitted in case multiple unresolved commands without callback got rejected in debug_mode.
-They are all aggregated and a single error is emitted in that case.
+Currently the following error subclasses exist:
+
+* `RedisError`: _All errors_ returned by the client
+* `ReplyError` subclass of `RedisError`: All errors returned by __Redis__ itself
+* `AbortError` subclass of `RedisError`: All commands that could not finish due
+  to what ever reason
+* `ParserError` subclass of `RedisError`: Returned in case of a parser error
+  (this should not happen)
+* `AggregateError` subclass of `AbortError`: Emitted in case multiple unresolved
+  commands without callback got rejected in debug_mode instead of lots of
+  `AbortError`s.
+
+All error classes are exported by the module.
 
 Example:
 ```js
@@ -311,10 +366,11 @@ client.on('error', function (err) {
     assert(err instanceof Error);
     assert(err instanceof redis.AbortError);
     assert(err instanceof redis.AggregateError);
-    assert.strictEqual(err.errors.length, 2); // The set and get got aggregated in here
+    // The set and get get aggregated in here
+    assert.strictEqual(err.errors.length, 2);
     assert.strictEqual(err.code, 'NR_CLOSED');
 });
-client.set('foo', 123, 'bar', function (err, res) { // To many arguments
+client.set('foo', 123, 'bar', function (err, res) { // Too many arguments
     assert(err instanceof redis.ReplyError); // => true
     assert.strictEqual(err.command, 'SET');
     assert.deepStrictEqual(err.args, ['foo', 123, 'bar']);
@@ -323,7 +379,8 @@ client.set('foo', 123, 'bar', function (err, res) { // To many arguments
     client.set('foo', 'bar');
     client.get('foo');
     process.nextTick(function () {
-        client.end(true); // Force closing the connection while the command did not yet return
+        // Force closing the connection while the command did not yet return
+        client.end(true);
         redis.debug_mode = false;
     });
 });
@@ -332,25 +389,33 @@ client.set('foo', 123, 'bar', function (err, res) { // To many arguments
 
 Every `ReplyError` contains the `command` name in all-caps and the arguments (`args`).
 
-If node_redis emits a library error because of another error, the triggering error is added to the returned error as `origin` attribute.
+If node_redis emits a library error because of another error, the triggering
+error is added to the returned error as `origin` attribute.
 
 ___Error codes___
 
-node_redis returns a `NR_CLOSED` error code if the clients connection dropped. If a command unresolved command got rejected a `UNERCTAIN_STATE` code is returned.
-A `CONNECTION_BROKEN` error code is used in case node_redis gives up to reconnect.
+node_redis returns a `NR_CLOSED` error code if the clients connection dropped.
+If a command unresolved command got rejected a `UNCERTAIN_STATE` code is
+returned. A `CONNECTION_BROKEN` error code is used in case node_redis gives up
+to reconnect.
 
 ## client.unref()
 
-Call `unref()` on the underlying socket connection to the Redis server, allowing the program to exit once no more commands are pending.
+Call `unref()` on the underlying socket connection to the Redis server, allowing
+the program to exit once no more commands are pending.
 
-This is an **experimental** feature, and only supports a subset of the Redis protocol. Any commands where client state is saved on the Redis server, e.g. `*SUBSCRIBE` or the blocking `BL*` commands will *NOT* work with `.unref()`.
+This is an **experimental** feature, and only supports a subset of the Redis
+protocol. Any commands where client state is saved on the Redis server, e.g.
+`*SUBSCRIBE` or the blocking `BL*` commands will *NOT* work with `.unref()`.
 
 ```js
 var redis = require("redis")
 var client = redis.createClient()
 
 /*
-    Calling unref() will allow this program to exit immediately after the get command finishes. Otherwise the client would hang as long as the client-server connection is alive.
+    Calling unref() will allow this program to exit immediately after the get
+    command finishes. Otherwise the client would hang as long as the
+    client-server connection is alive.
 */
 client.unref()
 client.get("foo", function (err, value){
@@ -361,13 +426,15 @@ client.get("foo", function (err, value){
 
 ## Friendlier hash commands
 
-Most Redis commands take a single String or an Array of Strings as arguments, and replies are sent back as a single String or an Array of Strings.
-When dealing with hash values, there are a couple of useful exceptions to this.
+Most Redis commands take a single String or an Array of Strings as arguments,
+and replies are sent back as a single String or an Array of Strings. When
+dealing with hash values, there are a couple of useful exceptions to this.
 
 ### client.hgetall(hash, callback)
 
-The reply from an HGETALL command will be converted into a JavaScript Object by `node_redis`. That way you can interact
-with the responses using JavaScript syntax.
+The reply from an HGETALL command will be converted into a JavaScript Object by
+`node_redis`. That way you can interact with the responses using JavaScript
+syntax.
 
 Example:
 
@@ -395,7 +462,8 @@ client.HMSET(key2, {
 });
 ```
 
-The properties and values of this Object will be set as keys and values in the Redis hash.
+The properties and values of this Object will be set as keys and values in the
+Redis hash.
 
 ### client.hmset(hash, key1, val1, ... keyn, valn, [callback])
 
@@ -435,11 +503,13 @@ sub.on("message", function (channel, message) {
 sub.subscribe("a nice channel");
 ```
 
-When a client issues a `SUBSCRIBE` or `PSUBSCRIBE`, that connection is put into a "subscriber" mode.
-At that point, only commands that modify the subscription set are valid and quit (and depending on the redis version ping as well). When the subscription
-set is empty, the connection is put back into regular mode.
+When a client issues a `SUBSCRIBE` or `PSUBSCRIBE`, that connection is put into
+a "subscriber" mode. At that point, only commands that modify the subscription
+set are valid and quit (and depending on the redis version ping as well). When
+the subscription set is empty, the connection is put back into regular mode.
 
-If you need to send regular commands to Redis while in subscriber mode, just open another connection with a new client (hint: use `client.duplicate()`).
+If you need to send regular commands to Redis while in subscriber mode, just
+open another connection with a new client (hint: use `client.duplicate()`).
 
 ## Subscriber Events
 
@@ -452,47 +522,57 @@ Listeners are passed the channel name as `channel` and the message as `message`.
 
 ### "pmessage" (pattern, channel, message)
 
-Client will emit `pmessage` for every message received that matches an active subscription pattern.
-Listeners are passed the original pattern used with `PSUBSCRIBE` as `pattern`, the sending channel
-name as `channel`, and the message as `message`.
+Client will emit `pmessage` for every message received that matches an active
+subscription pattern. Listeners are passed the original pattern used with
+`PSUBSCRIBE` as `pattern`, the sending channel name as `channel`, and the
+message as `message`.
 
 ### "message_buffer" (channel, message)
 
-This is the same as the `message` event with the exception, that it is always going to emit a buffer.
-If you listen to the `message` event at the same time as the `message_buffer`, it is always going to emit a string.
+This is the same as the `message` event with the exception, that it is always
+going to emit a buffer. If you listen to the `message` event at the same time as
+the `message_buffer`, it is always going to emit a string.
 
 ### "pmessage_buffer" (pattern, channel, message)
 
-This is the same as the `pmessage` event with the exception, that it is always going to emit a buffer.
-If you listen to the `pmessage` event at the same time as the `pmessage_buffer`, it is always going to emit a string.
+This is the same as the `pmessage` event with the exception, that it is always
+going to emit a buffer. If you listen to the `pmessage` event at the same time
+as the `pmessage_buffer`, it is always going to emit a string.
 
 ### "subscribe" (channel, count)
 
-Client will emit `subscribe` in response to a `SUBSCRIBE` command. Listeners are passed the
-channel name as `channel` and the new count of subscriptions for this client as `count`.
+Client will emit `subscribe` in response to a `SUBSCRIBE` command. Listeners are
+passed the channel name as `channel` and the new count of subscriptions for this
+client as `count`.
 
 ### "psubscribe" (pattern, count)
 
-Client will emit `psubscribe` in response to a `PSUBSCRIBE` command. Listeners are passed the
-original pattern as `pattern`, and the new count of subscriptions for this client as `count`.
+Client will emit `psubscribe` in response to a `PSUBSCRIBE` command. Listeners
+are passed the original pattern as `pattern`, and the new count of subscriptions
+for this client as `count`.
 
 ### "unsubscribe" (channel, count)
 
-Client will emit `unsubscribe` in response to a `UNSUBSCRIBE` command. Listeners are passed the
-channel name as `channel` and the new count of subscriptions for this client as `count`. When
-`count` is 0, this client has left subscriber mode and no more subscriber events will be emitted.
+Client will emit `unsubscribe` in response to a `UNSUBSCRIBE` command. Listeners
+are passed the channel name as `channel` and the new count of subscriptions for
+this client as `count`. When `count` is 0, this client has left subscriber mode
+and no more subscriber events will be emitted.
 
 ### "punsubscribe" (pattern, count)
 
-Client will emit `punsubscribe` in response to a `PUNSUBSCRIBE` command. Listeners are passed the
-channel name as `channel` and the new count of subscriptions for this client as `count`. When
-`count` is 0, this client has left subscriber mode and no more subscriber events will be emitted.
+Client will emit `punsubscribe` in response to a `PUNSUBSCRIBE` command.
+Listeners are passed the channel name as `channel` and the new count of
+subscriptions for this client as `count`. When `count` is 0, this client has
+left subscriber mode and no more subscriber events will be emitted.
 
 ## client.multi([commands])
 
-`MULTI` commands are queued up until an `EXEC` is issued, and then all commands are run atomically by
-Redis. The interface in `node_redis` is to return an individual `Multi` object by calling `client.multi()`.
-If any command fails to queue, all commands are rolled back and none is going to be executed (For further information look at [transactions](http://redis.io/topics/transactions)).
+`MULTI` commands are queued up until an `EXEC` is issued, and then all commands
+are run atomically by Redis. The interface in `node_redis` is to return an
+individual `Multi` object by calling `client.multi()`. If any command fails to
+queue, all commands are rolled back and none is going to be executed (For
+further information look at
+[transactions](http://redis.io/topics/transactions)).
 
 ```js
 var redis  = require("./index"),
@@ -526,15 +606,20 @@ client.multi()
 
 ### Multi.exec([callback])
 
-`client.multi()` is a constructor that returns a `Multi` object. `Multi` objects share all of the
-same command methods as `client` objects do. Commands are queued up inside the `Multi` object
-until `Multi.exec()` is invoked.
+`client.multi()` is a constructor that returns a `Multi` object. `Multi` objects
+share all of the same command methods as `client` objects do. Commands are
+queued up inside the `Multi` object until `Multi.exec()` is invoked.
 
-If your code contains an syntax error an EXECABORT error is going to be thrown and all commands are going to be aborted. That error contains a `.errors` property that contains the concret errors.
-If all commands were queued successfully and an error is thrown by redis while processing the commands that error is going to be returned in the result array! No other command is going to be aborted though than the onces failing.
+If your code contains an syntax error an EXECABORT error is going to be thrown
+and all commands are going to be aborted. That error contains a `.errors`
+property that contains the concrete errors.
+If all commands were queued successfully and an error is thrown by redis while
+processing the commands that error is going to be returned in the result array!
+No other command is going to be aborted though than the onces failing.
 
-You can either chain together `MULTI` commands as in the above example, or you can queue individual
-commands while still sending regular client command as in this example:
+You can either chain together `MULTI` commands as in the above example, or you
+can queue individual commands while still sending regular client command as in
+this example:
 
 ```js
 var redis  = require("redis"),
@@ -554,8 +639,8 @@ multi.exec(function (err, replies) {
 });
 ```
 
-In addition to adding commands to the `MULTI` queue individually, you can also pass an array
-of commands and arguments to the constructor:
+In addition to adding commands to the `MULTI` queue individually, you can also
+pass an array of commands and arguments to the constructor:
 
 ```js
 var redis  = require("redis"),
@@ -572,26 +657,36 @@ client.multi([
 
 ### Multi.exec_atomic([callback])
 
-Identical to Multi.exec but with the difference that executing a single command will not use transactions.
+Identical to Multi.exec but with the difference that executing a single command
+will not use transactions.
 
 ## client.batch([commands])
 
-Identical to .multi without transactions. This is recommended if you want to execute many commands at once but don't have to rely on transactions.
+Identical to .multi without transactions. This is recommended if you want to
+execute many commands at once but don't have to rely on transactions.
 
-`BATCH` commands are queued up until an `EXEC` is issued, and then all commands are run atomically by
-Redis. The interface in `node_redis` is to return an individual `Batch` object by calling `client.batch()`.
-The only difference between .batch and .multi is that no transaction is going to be used.
-Be aware that the errors are - just like in multi statements - in the result. Otherwise both, errors and results could be returned at the same time.
+`BATCH` commands are queued up until an `EXEC` is issued, and then all commands
+are run atomically by Redis. The interface in `node_redis` is to return an
+individual `Batch` object by calling `client.batch()`. The only difference
+between .batch and .multi is that no transaction is going to be used.
+Be aware that the errors are - just like in multi statements - in the result.
+Otherwise both, errors and results could be returned at the same time.
 
-If you fire many commands at once this is going to boost the execution speed significantly compared to fireing the same commands in a loop without waiting for the result! See the benchmarks for further comparison. Please remember that all commands are kept in memory until they are fired.
+If you fire many commands at once this is going to boost the execution speed
+significantly compared to firing the same commands in a loop without waiting for
+the result! See the benchmarks for further comparison. Please remember that all
+commands are kept in memory until they are fired.
 
 ## Monitor mode
 
-Redis supports the `MONITOR` command, which lets you see all commands received by the Redis server
-across all client connections, including from other client libraries and other computers.
+Redis supports the `MONITOR` command, which lets you see all commands received
+by the Redis server across all client connections, including from other client
+libraries and other computers.
 
-A `monitor` event is going to be emitted for every command fired from any client connected to the server including the monitoring client itself.
-The callback for the `monitor` event takes a timestamp from the Redis server, an array of command arguments and the raw monitoring string.
+A `monitor` event is going to be emitted for every command fired from any client
+connected to the server including the monitoring client itself. The callback for
+the `monitor` event takes a timestamp from the Redis server, an array of command
+arguments and the raw monitoring string.
 
 Example:
 
@@ -613,10 +708,11 @@ Some other things you might like to know about.
 
 ## client.server_info
 
-After the ready probe completes, the results from the INFO command are saved in the `client.server_info`
-object.
+After the ready probe completes, the results from the INFO command are saved in
+the `client.server_info` object.
 
-The `versions` key contains an array of the elements of the version string for easy comparison.
+The `versions` key contains an array of the elements of the version string for
+easy comparison.
 
     > client.server_info.redis_version
     '2.3.0'
@@ -655,12 +751,15 @@ the second word as first parameter:
 
 ## client.duplicate([options][, callback])
 
-Duplicate all current options and return a new redisClient instance. All options passed to the duplicate function are going to replace the original option.
-If you pass a callback, duplicate is going to wait until the client is ready and returns it in the callback. If an error occurs in the meanwhile, that is going to return an error instead in the callback.
+Duplicate all current options and return a new redisClient instance. All options
+passed to the duplicate function are going to replace the original option. If
+you pass a callback, duplicate is going to wait until the client is ready and
+returns it in the callback. If an error occurs in the meanwhile, that is going
+to return an error instead in the callback.
 
-One example of when to use duplicate() would be to accomodate the connection- 
+One example of when to use duplicate() would be to accommodate the connection-
 blocking redis commands BRPOP, BLPOP, and BRPOPLPUSH.  If these commands
-are used on the same redisClient instance as non-blocking commands, the 
+are used on the same redisClient instance as non-blocking commands, the
 non-blocking ones may be queued up until after the blocking ones finish.
 
     var Redis=require('redis');
@@ -681,17 +780,25 @@ non-blocking ones may be queued up until after the blocking ones finish.
     };
     get();
     brpop();
-    
-Another reason to use duplicate() is when multiple DBs on the same server are 
+
+Another reason to use duplicate() is when multiple DBs on the same server are
 accessed via the redis SELECT command.  Each DB could use its own connection.
-    
+
 ## client.send_command(command_name[, [args][, callback]])
 
-All Redis commands have been added to the `client` object. However, if new commands are introduced before this library is updated,
-you can use `send_command()` to send arbitrary commands to Redis.
-The command_name has to be lower case.
+All Redis commands have been added to the `client` object. However, if new
+commands are introduced before this library is updated or if you want to add
+individual commands you can use `send_command()` to send arbitrary commands to
+Redis.
 
-All commands are sent as multi-bulk commands. `args` can either be an Array of arguments, or omitted / set to undefined.
+All commands are sent as multi-bulk commands. `args` can either be an Array of
+arguments, or omitted / set to undefined.
+
+## client.add_command(command_name)
+
+Calling add_command will add a new command to the prototype. The exact command
+name will be used when calling using this new command. Using arbitrary arguments
+is possible as with any other command.
 
 ## client.connected
 
@@ -699,19 +806,23 @@ Boolean tracking the state of the connection to the Redis server.
 
 ## client.command_queue_length
 
-The number of commands that have been sent to the Redis server but not yet replied to. You can use this to
-enforce some kind of maximum queue depth for commands while connected.
+The number of commands that have been sent to the Redis server but not yet
+replied to. You can use this to enforce some kind of maximum queue depth for
+commands while connected.
 
 ## client.offline_queue_length
 
-The number of commands that have been queued up for a future connection. You can use this to enforce
-some kind of maximum queue depth for pre-connection commands.
+The number of commands that have been queued up for a future connection. You can
+use this to enforce some kind of maximum queue depth for pre-connection
+commands.
 
 ### Commands with Optional and Keyword arguments
 
-This applies to anything that uses an optional `[WITHSCORES]` or `[LIMIT offset count]` in the [redis.io/commands](http://redis.io/commands) documentation.
+This applies to anything that uses an optional `[WITHSCORES]` or `[LIMIT offset
+count]` in the [redis.io/commands](http://redis.io/commands) documentation.
 
 Example:
+
 ```js
 var args = [ 'myzset', 1, 'one', 2, 'two', 3, 'three', 99, 'ninety-nine' ];
 client.zadd(args, function (err, response) {
@@ -784,10 +895,13 @@ clients: 1, NodeJS: 6.2.0, Redis: 3.2.0, parser: javascript, connected by: tcp
 
 To get debug output run your `node_redis` application with `NODE_DEBUG=redis`.
 
-This is also going to result in good stack traces opposed to useless ones otherwise for any async operation.
-If you only want to have good stack traces but not the debug output run your application in development mode instead (`NODE_ENV=development`).
+This is also going to result in good stack traces opposed to useless ones
+otherwise for any async operation.
+If you only want to have good stack traces but not the debug output run your
+application in development mode instead (`NODE_ENV=development`).
 
-Good stack traces are only activated in development and debug mode as this results in a significant performance penalty.
+Good stack traces are only activated in development and debug mode as this
+results in a significant performance penalty.
 
 ___Comparison___:
 Useless stack trace:
@@ -823,7 +937,8 @@ The original author of node_redis is [Matthew Ranney](https://github.com/mranney
 
 The current lead maintainer is [Ruben Bridgewater](https://github.com/BridgeAR)
 
-Many [others](https://github.com/NodeRedis/node_redis/graphs/contributors) contributed to `node_redis` too. Thanks to all of them!
+Many [others](https://github.com/NodeRedis/node_redis/graphs/contributors)
+contributed to `node_redis` too. Thanks to all of them!
 
 ## License
 
@@ -831,10 +946,20 @@ Many [others](https://github.com/NodeRedis/node_redis/graphs/contributors) contr
 
 ### Consolidation: It's time for celebration
 
-Right now there are two great redis clients around and both have some advantages above each other. We speak about ioredis and node_redis. So after talking to each other about how we could improve in working together we (that is @luin and @BridgeAR) decided to work towards a single library on the long run. But step by step.
+Right now there are two great redis clients around and both have some advantages
+above each other. We speak about ioredis and node_redis. So after talking to
+each other about how we could improve in working together we (that is @luin and
+@BridgeAR) decided to work towards a single library on the long run. But step by
+step.
 
-First of all, we want to split small parts of our libraries into others so that we're both able to use the same code. Those libraries are going to be maintained under the NodeRedis organization. This is going to reduce the maintance overhead, allows others to use the very same code, if they need it and it's way easyer for others to contribute to both libraries.
+First of all, we want to split small parts of our libraries into others so that
+we're both able to use the same code. Those libraries are going to be maintained
+under the NodeRedis organization. This is going to reduce the maintenance
+overhead, allows others to use the very same code, if they need it and it's way
+easyer for others to contribute to both libraries.
 
-We're very happy about this step towards working together as we both want to give you the best redis experience possible.
+We're very happy about this step towards working together as we both want to
+give you the best redis experience possible.
 
-If you want to join our cause by help maintaining something, please don't hesitate to contact either one of us.
+If you want to join our cause by help maintaining something, please don't
+hesitate to contact either one of us.

package/changelog.md

@@ -1,30 +1,66 @@
-Changelog
-=========
+# Changelog
+
+## v.2.8.0 - 31 Jul, 2017
+
+Features
+
+- Accept UPPER_CASE commands in send_command
+- Add arbitrary commands to the prototype by using `Redis.addCommand(name)`
+
+Bugfixes
+
+- Fixed not always copying subscribe unsubscribe arguments
+- Fixed emitting internal errors while reconnecting with auth
+- Fixed crashing with invalid url option
+
+## v.2.7.1 - 14 Mar, 2017
+
+Bugfixes
+
+- Fixed monitor mode not working in combination with IPv6 (2.6.0 regression)
+
+## v.2.7.0 - 11 Mar, 2017
+
+Features
+
+- All returned errors are from now a subclass of `RedisError`.
+
+Bugfixes
+
+- Fixed rename_commands not accepting `null` as value
+- Fixed `AbortError`s and `AggregateError`s not showing the error message in the stack trace
+
+## v.2.6.5 - 15 Jan, 2017
+
+Bugfixes
+
+- Fixed parser not being reset in case the redis connection closed ASAP for overcoming of output buffer limits
+- Fixed parser reset if (p)message_buffer listener is attached
 
 ## v.2.6.4 - 12 Jan, 2017
 
 Bugfixes
 
--  Fixed monitor mode not working in combination with IPv6, sockets or lua scripts (2.6.0 regression)
+- Fixed monitor mode not working in combination with IPv6, sockets or lua scripts (2.6.0 regression)
 
 ## v.2.6.3 - 31 Oct, 2016
 
 Bugfixes
 
--  Do not change the tls setting to camel_case
--  Fix domain handling in combination with the offline queue (2.5.3 regression)
+- Do not change the tls setting to camel_case
+- Fix domain handling in combination with the offline queue (2.5.3 regression)
 
 ## v.2.6.2 - 16 Jun, 2016
 
 Bugfixes
 
--  Fixed individual callbacks of a transaction not being called (2.6.0 regression)
+- Fixed individual callbacks of a transaction not being called (2.6.0 regression)
 
 ## v.2.6.1 - 02 Jun, 2016
 
 Bugfixes
 
--  Fixed invalid function name being exported
+- Fixed invalid function name being exported
 
 ## v.2.6.0 - 01 Jun, 2016
 
@@ -106,7 +142,7 @@ Features
 -  Monitor and pub sub mode now work together with the offline queue
  -  All commands that were send after a connection loss are now going to be send after reconnecting
 -  Activating monitor mode does now work together with arbitrary commands including pub sub mode
--  Pub sub mode is completly rewritten and all known issues fixed
+-  Pub sub mode is completely rewritten and all known issues fixed
 -  Added `string_numbers` option to get back strings instead of numbers
 -  Quit command is from now on always going to end the connection properly
 
@@ -149,7 +185,7 @@ Same changelog as the pre-release
 
 ## v.2.5.0-1 - 07 Mar, 2016
 
-This is a big release with some substaintual underlining changes. Therefor this is released as a pre-release and I encourage anyone who's able to, to test this out.
+This is a big release with some substantial underlining changes. Therefor this is released as a pre-release and I encourage anyone who's able to, to test this out.
 
 It took way to long to release this one and the next release cycles will be shorter again.
 
@@ -169,7 +205,7 @@ Features
 -  Added a `warning` emitter that receives node_redis warnings like auth not required and deprecation messages
 -  Added a `retry_strategy` option that replaces all reconnect options
 -  The reconnecting event from now on also receives:
- -  The error message why the reconnect happend (params.error)
+ -  The error message why the reconnect happened (params.error)
  -  The amount of times the client was connected (params.times_connected)
  -  The total reconnecting time since the last time connected (params.total_retry_time)
 -  Always respect the command execution order no matter if the reply could be returned sync or not (former exceptions: [#937](https://github.com/NodeRedis/node_redis/issues/937#issuecomment-167525939))
@@ -184,9 +220,9 @@ Bugfixes
 -  Fixed do not run toString on an array argument and throw a "invalid data" error instead
  -  This is not considered as breaking change, as this is likely a error in your code and if you want to have such a behavior you should handle this beforehand
  -  The same applies to Map / Set and individual Object types
--  Fixed redis url not accepting the protocol being omitted or protocols other than the redis protocol for convienence
+-  Fixed redis url not accepting the protocol being omitted or protocols other than the redis protocol for convenience
 -  Fixed parsing the db keyspace even if the first database does not begin with a zero
--  Fixed handling of errors occuring while receiving pub sub messages
+-  Fixed handling of errors occurring while receiving pub sub messages
 -  Fixed huge string pipelines crashing NodeJS (Pipeline size above 256mb)
 -  Fixed rename_commands and prefix option not working together
 -  Fixed ready being emitted to early in case a slave is still syncing / master down
@@ -199,7 +235,7 @@ Deprecations
  -  Using SET or SETEX with a undefined or null value will from now on also result in converting the value to "null" / "undefined" to have a consistent behavior. This is not considered as breaking change, as it returned an error earlier.
 -  Using .end(flush) without the flush parameter is deprecated and the flush parameter should explicitly be used
  -  From v.3.0.0 on using .end without flush will result in an error
- -  Using .end without flush means that any command that did not yet return is going to silently fail. Therefor this is considered harmfull and you should explicitly silence such errors if you are sure you want this
+ -  Using .end without flush means that any command that did not yet return is going to silently fail. Therefor this is considered harmful and you should explicitly silence such errors if you are sure you want this
 -  Depending on the return value of a command to detect the backpressure is deprecated
  -  From version 3.0.0 on node_redis might not return true / false as a return value anymore. Please rely on client.should_buffer instead
 -  The `socket_nodelay` option is deprecated and will be removed in v.3.0.0

package/index.js

@@ -120,7 +120,7 @@ function RedisClient (options, stream) {
     if ('max_attempts' in options) {
         self.warn(
             'max_attempts is deprecated and will be removed in v.3.0.0.\n' +
-            'To reduce the amount of options and the improve the reconnection handling please use the new `retry_strategy` option instead.\n' +
+            'To reduce the number of options and to improve the reconnection handling please use the new `retry_strategy` option instead.\n' +
             'This replaces the max_attempts and retry_max_delay option.'
         );
     }
@@ -156,8 +156,6 @@ function RedisClient (options, stream) {
     this.buffers = options.return_buffers || options.detect_buffers;
     this.options = options;
     this.reply = 'ON'; // Returning replies is the default
-    // Init parser
-    this.reply_parser = create_parser(this);
     this.create_stream();
     // The listeners will not be attached right away, so let's print the deprecation message while the listener is attached
     this.on('newListener', function (event) {
@@ -171,10 +169,16 @@ function RedisClient (options, stream) {
                 'The drain event listener is deprecated and will be removed in v.3.0.0.\n' +
                 'If you want to keep on listening to this event please listen to the stream drain event directly.'
             );
-        } else if (event === 'message_buffer' || event === 'pmessage_buffer' || event === 'messageBuffer' || event === 'pmessageBuffer' && !this.buffers) {
+        } else if ((event === 'message_buffer' || event === 'pmessage_buffer' || event === 'messageBuffer' || event === 'pmessageBuffer') && !this.buffers && !this.message_buffers) {
+            if (this.reply_parser.name !== 'javascript') {
+                return this.warn(
+                    'You attached the "' + event + '" listener without the returnBuffers option set to true.\n' +
+                    'Please use the JavaScript parser or set the returnBuffers option to true to return buffers.'
+                );
+            }
+            this.reply_parser.optionReturnBuffers = true;
             this.message_buffers = true;
             this.handle_reply = handle_detect_buffers_reply;
-            this.reply_parser = create_parser(this);
         }
     });
 }
@@ -224,6 +228,9 @@ function create_parser (self) {
 RedisClient.prototype.create_stream = function () {
     var self = this;
 
+    // Init parser
+    this.reply_parser = create_parser(this);
+
     if (this.options.stream) {
         // Only add the listeners once in case of a reconnect try (that won't work)
         if (this.stream) {
@@ -297,7 +304,12 @@ RedisClient.prototype.create_stream = function () {
     // Fire the command before redis is connected to be sure it's the first fired command
     if (this.auth_pass !== undefined) {
         this.ready = true;
-        this.auth(this.auth_pass);
+        // Fail silently as we might not be able to connect
+        this.auth(this.auth_pass, function (err) {
+            if (err && err.code !== 'UNCERTAIN_STATE') {
+                self.emit('error', err);
+            }
+        });
         this.ready = false;
     }
 };
@@ -924,7 +936,7 @@ RedisClient.prototype.internal_send_command = function (command_obj) {
             args_copy[i] = this.options.prefix + args_copy[i];
         }
     }
-    if (typeof this.options.rename_commands !== 'undefined' && this.options.rename_commands[command]) {
+    if (this.options.rename_commands && this.options.rename_commands[command]) {
         command = this.options.rename_commands[command];
     }
     // Always use 'Multi bulk commands', but if passed any Buffer args, then do multiple writes, one for each arg.
@@ -1080,10 +1092,14 @@ exports.RedisClient = RedisClient;
 exports.print = utils.print;
 exports.Multi = require('./lib/multi');
 exports.AbortError = errorClasses.AbortError;
+exports.RedisError = Parser.RedisError;
+exports.ParserError = Parser.ParserError;
 exports.ReplyError = Parser.ReplyError;
 exports.AggregateError = errorClasses.AggregateError;
 
 // Add all redis commands / node_redis api to the client
 require('./lib/individualCommands');
 require('./lib/extendedApi');
-require('./lib/commands');
+
+//enables adding new commands (for modules and new commands)
+exports.addCommand = exports.add_command = require('./lib/commands');

package/lib/commands.js

@@ -17,11 +17,7 @@ var changeFunctionName = (function () {
     }
 }());
 
-// TODO: Rewrite this including the invidual commands into a Commands class
-// that provided a functionality to add new commands to the client
-
-commands.list.forEach(function (command) {
-
+var addCommand = function (command) {
     // Some rare Redis commands use special characters in their command name
     // Convert those to a underscore to prevent using invalid function names
     var commandName = command.replace(/(?:^([0-9])|[^a-zA-Z0-9_$])/g, '_$1');
@@ -61,6 +57,10 @@ commands.list.forEach(function (command) {
             }
             return this.internal_send_command(new Command(command, arr, callback));
         };
+        // Alias special function names (e.g. NR.RUN becomes NR_RUN and nr_run)
+        if (commandName !== command) {
+            RedisClient.prototype[commandName.toUpperCase()] = RedisClient.prototype[commandName] = RedisClient.prototype[command];
+        }
         if (changeFunctionName) {
             Object.defineProperty(RedisClient.prototype[command], 'name', {
                 value: commandName
@@ -104,10 +104,18 @@ commands.list.forEach(function (command) {
             this.queue.push(new Command(command, arr, callback));
             return this;
         };
+        // Alias special function names (e.g. NR.RUN becomes NR_RUN and nr_run)
+        if (commandName !== command) {
+            Multi.prototype[commandName.toUpperCase()] = Multi.prototype[commandName] = Multi.prototype[command];
+        }
         if (changeFunctionName) {
             Object.defineProperty(Multi.prototype[command], 'name', {
                 value: commandName
             });
         }
     }
-});
+};
+
+commands.list.forEach(addCommand);
+
+module.exports = addCommand;

package/lib/createClient.js

@@ -23,7 +23,8 @@ module.exports = function createClient (port_arg, host_arg, options) {
     } else if (typeof port_arg === 'string' || port_arg && port_arg.url) {
 
         options = utils.clone(port_arg.url ? port_arg : host_arg || options);
-        var parsed = URL.parse(port_arg.url || port_arg, true, true);
+        var url = port_arg.url || port_arg;
+        var parsed = URL.parse(url, true, true);
 
         // [redis:]//[[user][:password]@][host][:port][/db-number][?db=db-number[&password=bar[&option=value]]]
         if (parsed.slashes) { // We require slashes
@@ -59,7 +60,7 @@ module.exports = function createClient (port_arg, host_arg, options) {
         } else if (parsed.hostname) {
             throw new RangeError('The redis url must begin with slashes "//" or contain slashes after the redis protocol');
         } else {
-            options.path = port_arg;
+            options.path = url;
         }
 
     } else if (typeof port_arg === 'object' || port_arg === undefined) {

package/lib/customErrors.js

@@ -1,42 +1,55 @@
 'use strict';
 
 var util = require('util');
+var assert = require('assert');
+var RedisError = require('redis-parser').RedisError;
+var ADD_STACKTRACE = false;
 
-function AbortError (obj) {
-    Error.captureStackTrace(this, this.constructor);
+function AbortError (obj, stack) {
+    assert(obj, 'The options argument is required');
+    assert.strictEqual(typeof obj, 'object', 'The options argument has to be of type object');
+
+    RedisError.call(this, obj.message, ADD_STACKTRACE);
     Object.defineProperty(this, 'message', {
         value: obj.message || '',
         configurable: true,
         writable: true
     });
+    if (stack || stack === undefined) {
+        Error.captureStackTrace(this, AbortError);
+    }
     for (var keys = Object.keys(obj), key = keys.pop(); key; key = keys.pop()) {
         this[key] = obj[key];
     }
 }
 
 function AggregateError (obj) {
-    Error.captureStackTrace(this, this.constructor);
+    assert(obj, 'The options argument is required');
+    assert.strictEqual(typeof obj, 'object', 'The options argument has to be of type object');
+
+    AbortError.call(this, obj, ADD_STACKTRACE);
     Object.defineProperty(this, 'message', {
         value: obj.message || '',
         configurable: true,
         writable: true
     });
+    Error.captureStackTrace(this, AggregateError);
     for (var keys = Object.keys(obj), key = keys.pop(); key; key = keys.pop()) {
         this[key] = obj[key];
     }
 }
 
-util.inherits(AbortError, Error);
+util.inherits(AbortError, RedisError);
 util.inherits(AggregateError, AbortError);
 
 Object.defineProperty(AbortError.prototype, 'name', {
     value: 'AbortError',
-    // configurable: true,
+    configurable: true,
     writable: true
 });
 Object.defineProperty(AggregateError.prototype, 'name', {
     value: 'AggregateError',
-    // configurable: true,
+    configurable: true,
     writable: true
 });
 

package/lib/extendedApi.js

@@ -16,6 +16,7 @@ RedisClient.prototype.send_command = RedisClient.prototype.sendCommand = functio
     if (typeof command !== 'string') {
         throw new TypeError('Wrong input type "' + (command !== null && command !== undefined ? command.constructor.name : command) + '" for command name');
     }
+    command = command.toLowerCase();
     if (!Array.isArray(args)) {
         if (args === undefined || args === null) {
             args = [];
@@ -32,9 +33,9 @@ RedisClient.prototype.send_command = RedisClient.prototype.sendCommand = functio
 
     // Using the raw multi command is only possible with this function
     // If the command is not yet added to the client, the internal function should be called right away
-    // Otherwise we need to redirect the calls to make sure the interal functions don't get skipped
+    // Otherwise we need to redirect the calls to make sure the internal functions don't get skipped
     // The internal functions could actually be used for any non hooked function
-    // but this might change from time to time and at the moment there's no good way to distinguishe them
+    // but this might change from time to time and at the moment there's no good way to distinguish them
     // from each other, so let's just do it do it this way for the time being
     if (command === 'multi' || typeof this[command] !== 'function') {
         return this.internal_send_command(new Command(command, args, callback));

package/lib/individualCommands.js

@@ -398,7 +398,7 @@ RedisClient.prototype.subscribe = RedisClient.prototype.SUBSCRIBE = function sub
         callback,
         i = 0;
     if (Array.isArray(arguments[0])) {
-        arr = arguments[0];
+        arr = arguments[0].slice(0);
         callback = arguments[1];
     } else {
         len = arguments.length;
@@ -425,7 +425,7 @@ Multi.prototype.subscribe = Multi.prototype.SUBSCRIBE = function subscribe () {
         callback,
         i = 0;
     if (Array.isArray(arguments[0])) {
-        arr = arguments[0];
+        arr = arguments[0].slice(0);
         callback = arguments[1];
     } else {
         len = arguments.length;
@@ -453,7 +453,7 @@ RedisClient.prototype.unsubscribe = RedisClient.prototype.UNSUBSCRIBE = function
         callback,
         i = 0;
     if (Array.isArray(arguments[0])) {
-        arr = arguments[0];
+        arr = arguments[0].slice(0);
         callback = arguments[1];
     } else {
         len = arguments.length;
@@ -481,7 +481,7 @@ Multi.prototype.unsubscribe = Multi.prototype.UNSUBSCRIBE = function unsubscribe
         callback,
         i = 0;
     if (Array.isArray(arguments[0])) {
-        arr = arguments[0];
+        arr = arguments[0].slice(0);
         callback = arguments[1];
     } else {
         len = arguments.length;
@@ -510,7 +510,7 @@ RedisClient.prototype.psubscribe = RedisClient.prototype.PSUBSCRIBE = function p
         callback,
         i = 0;
     if (Array.isArray(arguments[0])) {
-        arr = arguments[0];
+        arr = arguments[0].slice(0);
         callback = arguments[1];
     } else {
         len = arguments.length;
@@ -537,7 +537,7 @@ Multi.prototype.psubscribe = Multi.prototype.PSUBSCRIBE = function psubscribe ()
         callback,
         i = 0;
     if (Array.isArray(arguments[0])) {
-        arr = arguments[0];
+        arr = arguments[0].slice(0);
         callback = arguments[1];
     } else {
         len = arguments.length;
@@ -565,7 +565,7 @@ RedisClient.prototype.punsubscribe = RedisClient.prototype.PUNSUBSCRIBE = functi
         callback,
         i = 0;
     if (Array.isArray(arguments[0])) {
-        arr = arguments[0];
+        arr = arguments[0].slice(0);
         callback = arguments[1];
     } else {
         len = arguments.length;
@@ -593,7 +593,7 @@ Multi.prototype.punsubscribe = Multi.prototype.PUNSUBSCRIBE = function punsubscr
         callback,
         i = 0;
     if (Array.isArray(arguments[0])) {
-        arr = arguments[0];
+        arr = arguments[0].slice(0);
         callback = arguments[1];
     } else {
         len = arguments.length;

package/lib/utils.js

@@ -127,7 +127,7 @@ module.exports = {
     reply_to_object: replyToObject,
     print: print,
     err_code: /^([A-Z]+)\s+(.+)$/,
-    monitor_regex: /^[0-9]{10,11}\.[0-9]+ \[[0-9]{1,3} (.(?!\]))+.\]( ".+?")+$/,
+    monitor_regex: /^[0-9]{10,11}\.[0-9]+ \[[0-9]+ .+\]( ".+?")+$/,
     clone: convenienceClone,
     callback_or_emit: callbackOrEmit,
     reply_in_order: replyInOrder

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redis",
-  "version": "2.6.4",
+  "version": "2.8.0",
   "description": "Redis client library",
   "keywords": [
     "database",
@@ -27,7 +27,7 @@
   "dependencies": {
     "double-ended-queue": "^2.1.0-0",
     "redis-commands": "^1.2.0",
-    "redis-parser": "^2.0.0"
+    "redis-parser": "^2.6.0"
   },
   "engines": {
     "node": ">=0.10.0"
@@ -35,11 +35,11 @@
   "devDependencies": {
     "bluebird": "^3.0.2",
     "coveralls": "^2.11.2",
+    "eslint": "^4.2.0",
     "intercept-stdout": "~0.1.2",
-    "eslint": "^3.5.0",
     "metrics": "^0.1.9",
-    "mocha": "^2.3.2",
-    "nyc": "^8.3.0",
+    "mocha": "^3.1.2",
+    "nyc": "^10.0.0",
     "tcp-port-used": "^0.1.2",
     "uuid": "^2.0.1",
     "win-spawn": "^2.0.0"