redis 2.6.0-2 → 2.6.3

package/README.md

@@ -1,12 +1,12 @@
 redis - a node.js redis client
 ===========================
 
-[![Build Status](https://travis-ci.org/NodeRedis/node_redis.png)](https://travis-ci.org/NodeRedis/node_redis)
+[![Build Status](https://travis-ci.org/NodeRedis/node_redis.svg?branch=master)](https://travis-ci.org/NodeRedis/node_redis)
 [![Coverage Status](https://coveralls.io/repos/NodeRedis/node_redis/badge.svg?branch=)](https://coveralls.io/r/NodeRedis/node_redis?branch=)
 [![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:
 
@@ -49,7 +49,7 @@ This will display:
     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 snack_case and all options / variables / events etc. can be used either way.
+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
@@ -182,15 +182,15 @@ __Tip:__ If the Redis server runs on the same machine as the client consider usi
 | port      | 6379      | Port of the Redis server |
 | path      | null      | The UNIX socket string of the Redis server |
 | url       | null      | The URL of the Redis server. Format: `[redis:]//[[user][:password@]][host][:port][/db-number][?db=db-number[&password=bar[&option=value]]]` (More info avaliable at [IANA](http://www.iana.org/assignments/uri-schemes/prov/redis)). |
-| parser    | hiredis   |  If hiredis is not installed, automatic fallback to the built-in javascript parser |
-| string_numbers | null   | Set to `true`, `node_redis` will return Redis number values as Strings instead of javascript Numbers. Useful if you need to handle big numbers (above `Number.MAX_SAFE_INTEGER === 2^53`). Hiredis is incapable of this behavior, so setting this option to `true` will result in the built-in javascript parser being used no matter the value of the `parser` option. |
+| parser    | javascript | __Deprecated__ Use either the built-in JS parser [`javascript`]() or the native [`hiredis`]() parser. __Note__ `node_redis` < 2.6 uses hiredis as default if installed. This changed in v.2.6.0. |
+| string_numbers | null | Set to `true`, `node_redis` will return Redis number values as Strings instead of javascript Numbers. Useful if you need to handle big numbers (above `Number.MAX_SAFE_INTEGER === 2^53`). Hiredis is incapable of this behavior, so setting this option to `true` will result in the built-in javascript parser being used no matter the value of the `parser` option. |
 | return_buffers | false | If set to `true`, then all replies will be sent to callbacks as Buffers instead of Strings. |
 | detect_buffers | false | If set to `true`, then replies will be sent to callbacks as Buffers. This option lets you switch between Buffers and Strings on a per-command basis, whereas `return_buffers` applies to every command on a client. __Note__: This doesn't work properly with the pubsub mode. A subscriber has to either always return Strings or Buffers. |
 | socket_keepalive | true | If set to `true`, the keep-alive functionality is enabled on the underlying socket. |
 | no_ready_check | false |  When a connection is established to the Redis server, the server might still be loading the database from disk. While loading, the server will not respond to any commands. To work around this, `node_redis` has a "ready check" which sends the `INFO` command to the server. The response from the `INFO` command indicates whether the server is ready for more commands. When ready, `node_redis` emits a `ready` event. Setting `no_ready_check` to `true` will inhibit this check. |
 | enable_offline_queue |  true | By default, if there is no active connection to the Redis server, commands are added to a queue and are executed once the connection has been established. Setting `enable_offline_queue` to `false` will disable this feature and the callback will be executed immediately with an error, or an error will be emitted if no callback is specified. |
-| retry_max_delay | null | By default, every time the client tries to connect and fails, the reconnection delay almost doubles. This delay normally grows infinitely, but setting `retry_max_delay` limits it to the maximum value provided in milliseconds. |
-| connect_timeout | 3600000 | Setting `connect_timeout` limits the total time for the client to connect and reconnect. The value is provided in milliseconds and is counted from the moment a new client is created or from the time the connection is lost. The last retry is going to happen exactly at the timeout time. Default is to try connecting until the default system socket timeout has been exceeded and to try reconnecting until 1h has elapsed. |
+| retry_max_delay | null | __Deprecated__ _Please use `retry_strategy` instead._ By default, every time the client tries to connect and fails, the reconnection delay almost doubles. This delay normally grows infinitely, but setting `retry_max_delay` limits it to the maximum value provided in milliseconds. |
+| connect_timeout | 3600000 | __Deprecated__ _Please use `retry_strategy` instead._ Setting `connect_timeout` limits the total time for the client to connect and reconnect. The value is provided in milliseconds and is counted from the moment a new client is created or from the time the connection is lost. The last retry is going to happen exactly at the timeout time. Default is to try connecting until the default system socket timeout has been exceeded and to try reconnecting until 1h has elapsed. |
 | max_attempts | 0 | __Deprecated__ _Please use `retry_strategy` instead._ By default, a client will try reconnecting until connected. Setting `max_attempts` limits total amount of connection attempts. Setting this to 1 will prevent any reconnect attempt. |
 | retry_unfulfilled_commands | false | If set to `true`, all commands that were unfulfilled while the connection is lost will be retried after the connection has been reestablished. Use this with caution if you use state altering commands (e.g. `incr`). This is especially useful if you use blocking commands. |
 | password | null | If set, client will run Redis auth command on connect. Alias `auth_pass` __Note__ `node_redis` < 2.5 must use `auth_pass` |
@@ -658,6 +658,33 @@ the second word as first parameter:
 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- 
+blocking redis commands BRPOP, BLPOP, and BRPOPLPUSH.  If these commands
+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');
+    var client = Redis.createClient();
+    var clientBlocking = client.duplicate();
+
+    var get = function() {
+        console.log("get called");
+        client.get("any_key",function() { console.log("get returned"); });
+        setTimeout( get, 1000 );
+    };
+    var brpop = function() {
+        console.log("brpop called");
+        clientBlocking.brpop("nonexistent", 5, function() {
+            console.log("brpop return");
+            setTimeout( brpop, 1000 );
+        });
+    };
+    get();
+    brpop();
+    
+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,
@@ -712,60 +739,80 @@ client.zadd(args, function (err, response) {
 ## Performance
 
 Much effort has been spent to make `node_redis` as fast as possible for common
-operations. As pipelining happens naturally from shared connections, overall
-efficiency goes up.
-
-Here are results of `multi_bench.js` which is similar to `redis-benchmark` from the Redis distribution.
-
-hiredis parser (Lenovo T450s i7-5600U):
+operations.
 
 ```
-Client count: 1, node version: 4.2.2, server version: 3.0.3, parser: hiredis
-         PING,         1/1 min/max/avg:    0/   2/   0.02/   2501ms total,  47503.80 ops/sec
-         PING,  batch 50/1 min/max/avg:    0/   2/   0.09/   2501ms total, 529668.13 ops/sec
-   SET 4B str,         1/1 min/max/avg:    0/   2/   0.02/   2501ms total,  41900.04 ops/sec
-   SET 4B str,  batch 50/1 min/max/avg:    0/   2/   0.14/   2501ms total, 354658.14 ops/sec
-   SET 4B buf,         1/1 min/max/avg:    0/   4/   0.04/   2501ms total,  23499.00 ops/sec
-   SET 4B buf,  batch 50/1 min/max/avg:    0/   2/   0.31/   2501ms total, 159836.07 ops/sec
-   GET 4B str,         1/1 min/max/avg:    0/   4/   0.02/   2501ms total,  43489.80 ops/sec
-   GET 4B str,  batch 50/1 min/max/avg:    0/   2/   0.11/   2501ms total, 444202.32 ops/sec
-   GET 4B buf,         1/1 min/max/avg:    0/   3/   0.02/   2501ms total,  38561.38 ops/sec
-   GET 4B buf,  batch 50/1 min/max/avg:    0/   2/   0.11/   2501ms total, 452139.14 ops/sec
- SET 4KiB str,         1/1 min/max/avg:    0/   2/   0.03/   2501ms total,  32990.80 ops/sec
- SET 4KiB str,  batch 50/1 min/max/avg:    0/   2/   0.34/   2501ms total, 146161.54 ops/sec
- SET 4KiB buf,         1/1 min/max/avg:    0/   1/   0.04/   2501ms total,  23294.28 ops/sec
- SET 4KiB buf,  batch 50/1 min/max/avg:    0/   2/   0.36/   2501ms total, 137584.97 ops/sec
- GET 4KiB str,         1/1 min/max/avg:    0/   2/   0.03/   2501ms total,  36350.66 ops/sec
- GET 4KiB str,  batch 50/1 min/max/avg:    0/   2/   0.32/   2501ms total, 155157.94 ops/sec
- GET 4KiB buf,         1/1 min/max/avg:    0/   4/   0.02/   2501ms total,  39776.49 ops/sec
- GET 4KiB buf,  batch 50/1 min/max/avg:    0/   2/   0.32/   2501ms total, 155457.82 ops/sec
-         INCR,         1/1 min/max/avg:    0/   3/   0.02/   2501ms total,  43972.41 ops/sec
-         INCR,  batch 50/1 min/max/avg:    0/   1/   0.12/   2501ms total, 425809.68 ops/sec
-        LPUSH,         1/1 min/max/avg:    0/   2/   0.02/   2501ms total,  38998.40 ops/sec
-        LPUSH,  batch 50/1 min/max/avg:    0/   4/   0.14/   2501ms total, 365013.99 ops/sec
-    LRANGE 10,         1/1 min/max/avg:    0/   2/   0.03/   2501ms total,  31879.25 ops/sec
-    LRANGE 10,  batch 50/1 min/max/avg:    0/   1/   0.32/   2501ms total, 153698.52 ops/sec
-   LRANGE 100,         1/1 min/max/avg:    0/   4/   0.06/   2501ms total,  16676.13 ops/sec
-   LRANGE 100,  batch 50/1 min/max/avg:    1/   6/   2.03/   2502ms total,  24520.38 ops/sec
- SET 4MiB str,         1/1 min/max/avg:    1/   6/   2.11/   2502ms total,    472.82 ops/sec
- SET 4MiB str,  batch 20/1 min/max/avg:   85/ 112/  94.93/   2563ms total,    210.69 ops/sec
- SET 4MiB buf,         1/1 min/max/avg:    1/   8/   2.02/   2502ms total,    490.01 ops/sec
- SET 4MiB buf,  batch 20/1 min/max/avg:   37/  52/  39.48/   2528ms total,    506.33 ops/sec
- GET 4MiB str,         1/1 min/max/avg:    3/  13/   5.26/   2504ms total,    190.10 ops/sec
- GET 4MiB str,  batch 20/1 min/max/avg:   70/ 106/  89.36/   2503ms total,    223.73 ops/sec
- GET 4MiB buf,         1/1 min/max/avg:    3/  11/   5.04/   2502ms total,    198.24 ops/sec
- GET 4MiB buf,  batch 20/1 min/max/avg:   70/ 105/  88.07/   2554ms total,    227.09 ops/sec
+Lenovo T450s, i7-5600U and 12gb memory
+clients: 1, NodeJS: 6.2.0, Redis: 3.2.0, parser: javascript, connected by: tcp
+         PING,         1/1 avg/max:   0.02/  5.26 2501ms total,   46916 ops/sec
+         PING,  batch 50/1 avg/max:   0.06/  4.35 2501ms total,  755178 ops/sec
+   SET 4B str,         1/1 avg/max:   0.02/  4.75 2501ms total,   40856 ops/sec
+   SET 4B str,  batch 50/1 avg/max:   0.11/  1.51 2501ms total,  432727 ops/sec
+   SET 4B buf,         1/1 avg/max:   0.05/  2.76 2501ms total,   20659 ops/sec
+   SET 4B buf,  batch 50/1 avg/max:   0.25/  1.76 2501ms total,  194962 ops/sec
+   GET 4B str,         1/1 avg/max:   0.02/  1.55 2501ms total,   45156 ops/sec
+   GET 4B str,  batch 50/1 avg/max:   0.09/  3.15 2501ms total,  524110 ops/sec
+   GET 4B buf,         1/1 avg/max:   0.02/  3.07 2501ms total,   44563 ops/sec
+   GET 4B buf,  batch 50/1 avg/max:   0.10/  3.18 2501ms total,  473171 ops/sec
+ SET 4KiB str,         1/1 avg/max:   0.03/  1.54 2501ms total,   32627 ops/sec
+ SET 4KiB str,  batch 50/1 avg/max:   0.34/  1.89 2501ms total,  146861 ops/sec
+ SET 4KiB buf,         1/1 avg/max:   0.05/  2.85 2501ms total,   20688 ops/sec
+ SET 4KiB buf,  batch 50/1 avg/max:   0.36/  1.83 2501ms total,  138165 ops/sec
+ GET 4KiB str,         1/1 avg/max:   0.02/  1.37 2501ms total,   39389 ops/sec
+ GET 4KiB str,  batch 50/1 avg/max:   0.24/  1.81 2501ms total,  208157 ops/sec
+ GET 4KiB buf,         1/1 avg/max:   0.02/  2.63 2501ms total,   39918 ops/sec
+ GET 4KiB buf,  batch 50/1 avg/max:   0.31/  8.56 2501ms total,  161575 ops/sec
+         INCR,         1/1 avg/max:   0.02/  4.69 2501ms total,   45685 ops/sec
+         INCR,  batch 50/1 avg/max:   0.09/  3.06 2501ms total,  539964 ops/sec
+        LPUSH,         1/1 avg/max:   0.02/  3.04 2501ms total,   41253 ops/sec
+        LPUSH,  batch 50/1 avg/max:   0.12/  1.94 2501ms total,  425090 ops/sec
+    LRANGE 10,         1/1 avg/max:   0.02/  2.28 2501ms total,   39850 ops/sec
+    LRANGE 10,  batch 50/1 avg/max:   0.25/  1.85 2501ms total,  194302 ops/sec
+   LRANGE 100,         1/1 avg/max:   0.05/  2.93 2501ms total,   21026 ops/sec
+   LRANGE 100,  batch 50/1 avg/max:   1.52/  2.89 2501ms total,   32767 ops/sec
+ SET 4MiB str,         1/1 avg/max:   5.16/ 15.55 2502ms total,     193 ops/sec
+ SET 4MiB str,  batch 20/1 avg/max:  89.73/ 99.96 2513ms total,     223 ops/sec
+ SET 4MiB buf,         1/1 avg/max:   2.23/  8.35 2501ms total,     446 ops/sec
+ SET 4MiB buf,  batch 20/1 avg/max:  41.47/ 50.91 2530ms total,     482 ops/sec
+ GET 4MiB str,         1/1 avg/max:   2.79/ 10.91 2502ms total,     358 ops/sec
+ GET 4MiB str,  batch 20/1 avg/max: 101.61/118.11 2541ms total,     197 ops/sec
+ GET 4MiB buf,         1/1 avg/max:   2.32/ 14.93 2502ms total,     430 ops/sec
+ GET 4MiB buf,  batch 20/1 avg/max:  65.01/ 84.72 2536ms total,     308 ops/sec
  ```
 
-The hiredis and js parser should most of the time be on the same level. But if you use Redis for big SUNION/SINTER/LRANGE/ZRANGE hiredis is faster.
-Therefor the hiredis parser is the default used in node_redis. To use `hiredis`, do:
-
-    npm install hiredis redis
-
 ## Debugging
 
 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`).
+
+Good stack traces are only activated in development and debug mode as this results in a significant performance penalty.
+
+___Comparison___:
+Useless stack trace:
+```
+ReplyError: ERR wrong number of arguments for 'set' command
+    at parseError (/home/ruben/repos/redis/node_modules/redis-parser/lib/parser.js:158:12)
+    at parseType (/home/ruben/repos/redis/node_modules/redis-parser/lib/parser.js:219:14)
+```
+Good stack trace:
+```
+ReplyError: ERR wrong number of arguments for 'set' command
+    at new Command (/home/ruben/repos/redis/lib/command.js:9:902)
+    at RedisClient.set (/home/ruben/repos/redis/lib/commands.js:9:3238)
+    at Context.<anonymous> (/home/ruben/repos/redis/test/good_stacks.spec.js:20:20)
+    at callFnAsync (/home/ruben/repos/redis/node_modules/mocha/lib/runnable.js:349:8)
+    at Test.Runnable.run (/home/ruben/repos/redis/node_modules/mocha/lib/runnable.js:301:7)
+    at Runner.runTest (/home/ruben/repos/redis/node_modules/mocha/lib/runner.js:422:10)
+    at /home/ruben/repos/redis/node_modules/mocha/lib/runner.js:528:12
+    at next (/home/ruben/repos/redis/node_modules/mocha/lib/runner.js:342:14)
+    at /home/ruben/repos/redis/node_modules/mocha/lib/runner.js:352:7
+    at next (/home/ruben/repos/redis/node_modules/mocha/lib/runner.js:284:14)
+    at Immediate._onImmediate (/home/ruben/repos/redis/node_modules/mocha/lib/runner.js:320:5)
+    at processImmediate [as _immediateCallback] (timers.js:383:17)
+```
+
 ## How to Contribute
 - Open a pull request or an issue about what you want to implement / change. We're glad for any help!
  - Please be aware that we'll only accept fully tested code.

package/changelog.md

@@ -1,18 +1,56 @@
 Changelog
 =========
 
+## 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)
+
+## v.2.6.2 - 16 Jun, 2016
+
+Bugfixes
+
+-  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
+
+## v.2.6.0 - 01 Jun, 2016
+
+In addition to the pre-releases the following changes exist in v.2.6.0:
+
+Features
+
+-  Updated [redis-parser](https://github.com/NodeRedis/node-redis-parser) dependency ([changelog](https://github.com/NodeRedis/node-redis-parser/releases/tag/v.2.0.0))
+ -  The JS parser is from now on the new default as it is a lot faster than the hiredis parser
+ -  This is no BC as there is no changed behavior for the user at all but just a performance improvement. Explicitly requireing the Hiredis parser is still possible.
+-  Added name property to all Redis functions (Node.js >= 4.0)
+-  Improved stack traces in development and debug mode
+
+Bugfixes
+
+-  Reverted support for `__proto__` (v.2.6.0-2) to prevent and breaking change
+
+Deprecations
+
+-  The `parser` option is deprecated and should be removed. The built-in Javascript parser is a lot faster than the hiredis parser and has more features
+
 ## v.2.6.0-2 - 29 Apr, 2016
 
 Features
 
--  Added support for the new `CLIENT REPLY ON|OFF|SKIP` command (Redis v.3.2)
+-  Added support for the new [CLIENT REPLY ON|OFF|SKIP](http://redis.io/commands/client-reply) command (Redis v.3.2)
 -  Added support for camelCase
  -  The Node.js landscape default is to use camelCase. node_redis is a bit out of the box here
     but from now on it is possible to use both, just as you prefer!
  -  If there's any documented variable missing as camelCased, please open a issue for it
 -  Improve error handling significantly
  -  Only emit an error if the error has not already been handled in a callback
- -  Emit an error if a command would otherwise silently fail (no callback present)
  -  Improved unspecific error messages e.g. "Connection gone from end / close event"
  -  Added `args` to command errors to improve identification of the error
  -  Added origin to errors if there's e.g. a connection error

package/index.js

@@ -4,10 +4,9 @@ var net = require('net');
 var tls = require('tls');
 var util = require('util');
 var utils = require('./lib/utils');
+var Command = require('./lib/command');
 var Queue = require('double-ended-queue');
 var errorClasses = require('./lib/customErrors');
-var Command = require('./lib/command').Command;
-var OfflineCommand = require('./lib/command').OfflineCommand;
 var EventEmitter = require('events');
 var Parser = require('redis-parser');
 var commands = require('redis-commands');
@@ -154,11 +153,11 @@ function RedisClient (options, stream) {
     this.pipeline = false;
     this.sub_commands_left = 0;
     this.times_connected = 0;
-    this.options = options;
     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, options);
+    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) {
@@ -184,18 +183,17 @@ util.inherits(RedisClient, EventEmitter);
 RedisClient.connection_id = 0;
 
 function create_parser (self) {
-    return Parser({
+    return new Parser({
         returnReply: function (data) {
             self.return_reply(data);
         },
         returnError: function (err) {
             // Return a ReplyError to indicate Redis returned an error
-            self.return_error(new errorClasses.ReplyError(err));
+            self.return_error(err);
         },
         returnFatalError: function (err) {
             // Error out all fired commands. Otherwise they might rely on faulty data. We have to reconnect to get in a working state again
             // Note: the execution order is important. First flush and emit, then create the stream
-            err = new errorClasses.ReplyError(err);
             err.message += '. Please report this.';
             self.ready = false;
             self.flush_and_error({
@@ -209,8 +207,8 @@ function create_parser (self) {
             self.create_stream();
         },
         returnBuffers: self.buffers || self.message_buffers,
-        name: self.options.parser,
-        stringNumbers: self.options.string_numbers
+        name: self.options.parser || 'javascript',
+        stringNumbers: self.options.string_numbers || false
     });
 }
 
@@ -350,6 +348,9 @@ RedisClient.prototype.flush_and_error = function (error_attributes, options) {
         // Don't flush everything from the queue
         for (var command_obj = this[queue_names[i]].shift(); command_obj; command_obj = this[queue_names[i]].shift()) {
             var err = new errorClasses.AbortError(error_attributes);
+            if (command_obj.error) {
+                err.stack = err.stack + command_obj.error.stack.replace(/^Error.*?\n/, '\n');
+            }
             err.command = command_obj.command.toUpperCase();
             if (command_obj.args && command_obj.args.length) {
                 err.args = command_obj.args;
@@ -444,14 +445,10 @@ RedisClient.prototype.on_ready = function () {
 
     // Restore modal commands from previous connection. The order of the commands is important
     if (this.selected_db !== undefined) {
-        this.internal_send_command('select', [this.selected_db]);
-    }
-    if (this.old_state !== null) {
-        this.monitoring = this.old_state.monitoring;
-        this.pub_sub_mode = this.old_state.pub_sub_mode;
+        this.internal_send_command(new Command('select', [this.selected_db]));
     }
     if (this.monitoring) { // Monitor has to be fired before pub sub commands
-        this.internal_send_command('monitor', []); // The state is still set
+        this.internal_send_command(new Command('monitor', []));
     }
     var callback_count = Object.keys(this.subscription_set).length;
     if (!this.options.disable_resubscribing && callback_count) {
@@ -467,8 +464,8 @@ RedisClient.prototype.on_ready = function () {
         debug('Sending pub/sub on_ready commands');
         for (var key in this.subscription_set) {
             var command = key.slice(0, key.indexOf('_'));
-            var args = self.subscription_set[key];
-            self.internal_send_command(command, [args], callback);
+            var args = this.subscription_set[key];
+            this[command]([args], callback);
         }
         this.send_offline_queue();
         return;
@@ -531,7 +528,7 @@ RedisClient.prototype.ready_check = function () {
 RedisClient.prototype.send_offline_queue = function () {
     for (var command_obj = this.offline_queue.shift(); command_obj; command_obj = this.offline_queue.shift()) {
         debug('Sending offline command: ' + command_obj.command);
-        this.internal_send_command(command_obj.command, command_obj.args, command_obj.callback, command_obj.call_on_write);
+        this.internal_send_command(command_obj);
     }
     this.drain();
 };
@@ -574,13 +571,6 @@ RedisClient.prototype.connection_gone = function (why, error) {
     this.cork = noop;
     this.uncork = noop;
     this.pipeline = false;
-
-    var state = {
-        monitoring: this.monitoring,
-        pub_sub_mode: this.pub_sub_mode
-    };
-    this.old_state = state;
-    this.monitoring = false;
     this.pub_sub_mode = 0;
 
     // since we are collapsing end and close, users don't expect to be called twice
@@ -682,6 +672,9 @@ RedisClient.prototype.connection_gone = function (why, error) {
 
 RedisClient.prototype.return_error = function (err) {
     var command_obj = this.command_queue.shift();
+    if (command_obj.error) {
+        err.stack = command_obj.error.stack.replace(/^Error.*?\n/, 'ReplyError: ' + err.message + '\n');
+    }
     err.command = command_obj.command.toUpperCase();
     if (command_obj.args && command_obj.args.length) {
         err.args = command_obj.args;
@@ -835,7 +828,6 @@ RedisClient.prototype.return_reply = function (reply) {
 
 function handle_offline_command (self, command_obj) {
     var command = command_obj.command;
-    var callback = command_obj.callback;
     var err, msg;
     if (self.closing || !self.enable_offline_queue) {
         command = command.toUpperCase();
@@ -853,10 +845,10 @@ function handle_offline_command (self, command_obj) {
             code: 'NR_CLOSED',
             command: command
         });
-        if (command_obj.args && command_obj.args.length) {
+        if (command_obj.args.length) {
             err.args = command_obj.args;
         }
-        utils.reply_in_order(self, callback, err);
+        utils.reply_in_order(self, command_obj.callback, err);
     } else {
         debug('Queueing ' + command + ' for next server connection.');
         self.offline_queue.push(command_obj);
@@ -866,22 +858,23 @@ function handle_offline_command (self, command_obj) {
 
 // Do not call internal_send_command directly, if you are not absolutly certain it handles everything properly
 // e.g. monitor / info does not work with internal_send_command only
-RedisClient.prototype.internal_send_command = function (command, args, callback, call_on_write) {
-    var arg, prefix_keys, command_obj;
+RedisClient.prototype.internal_send_command = function (command_obj) {
+    var arg, prefix_keys;
     var i = 0;
     var command_str = '';
+    var args = command_obj.args;
+    var command = command_obj.command;
     var len = args.length;
     var big_data = false;
-    var buffer_args = false;
     var args_copy = new Array(len);
 
-    if (process.domain && callback) {
-        callback = process.domain.bind(callback);
+    if (process.domain && command_obj.callback) {
+        command_obj.callback = process.domain.bind(command_obj.callback);
     }
 
     if (this.ready === false || this.stream.writable === false) {
         // Handle offline commands right away
-        handle_offline_command(this, new OfflineCommand(command, args, callback, call_on_write));
+        handle_offline_command(this, command_obj);
         return false; // Indicate buffering
     }
 
@@ -906,7 +899,7 @@ RedisClient.prototype.internal_send_command = function (command, args, callback,
                 args_copy[i] = 'null'; // Backwards compatible :/
             } else if (Buffer.isBuffer(args[i])) {
                 args_copy[i] = args[i];
-                buffer_args = true;
+                command_obj.buffer_args = true;
                 big_data = true;
             } else {
                 this.warn(
@@ -928,8 +921,6 @@ RedisClient.prototype.internal_send_command = function (command, args, callback,
             args_copy[i] = '' + args[i];
         }
     }
-    // Pass the original args to make sure in error cases the original arguments are returned
-    command_obj = new Command(command, args, buffer_args, callback);
 
     if (this.options.prefix) {
         prefix_keys = commands.getKeyIndexes(command, args_copy);
@@ -968,8 +959,8 @@ RedisClient.prototype.internal_send_command = function (command, args, callback,
             debug('send_command: buffer send ' + arg.length + ' bytes');
         }
     }
-    if (call_on_write) {
-        call_on_write();
+    if (command_obj.call_on_write) {
+        command_obj.call_on_write();
     }
     // Handle `CLIENT REPLY ON|OFF|SKIP`
     // This has to be checked after call_on_write
@@ -979,8 +970,8 @@ RedisClient.prototype.internal_send_command = function (command, args, callback,
     } else {
         // Do not expect a reply
         // Does this work in combination with the pub sub mode?
-        if (callback) {
-            utils.reply_in_order(this, callback, null, undefined, this.command_queue);
+        if (command_obj.callback) {
+            utils.reply_in_order(this, command_obj.callback, null, undefined, this.command_queue);
         }
         if (this.reply === 'SKIP') {
             this.reply = 'SKIP_ONE_MORE';
@@ -1043,7 +1034,7 @@ Object.defineProperty(RedisClient.prototype, 'offline_queue_length', {
 });
 
 // Add support for camelCase by adding read only properties to the client
-// All known exposed snack_case variables are added here
+// All known exposed snake_case variables are added here
 Object.defineProperty(RedisClient.prototype, 'retryDelay', {
     get: function () {
         return this.retry_delay;
@@ -1093,7 +1084,7 @@ exports.RedisClient = RedisClient;
 exports.print = utils.print;
 exports.Multi = require('./lib/multi');
 exports.AbortError = errorClasses.AbortError;
-exports.ReplyError = errorClasses.ReplyError;
+exports.ReplyError = Parser.ReplyError;
 exports.AggregateError = errorClasses.AggregateError;
 
 // Add all redis commands / node_redis api to the client

package/lib/command.js

@@ -1,22 +1,16 @@
 'use strict';
 
-// This Command constructor is ever so slightly faster than using an object literal, but more importantly, using
-// a named constructor helps it show up meaningfully in the V8 CPU profiler and in heap snapshots.
-function Command (command, args, buffer_args, callback) {
-    this.command = command;
-    this.args = args;
-    this.buffer_args = buffer_args;
-    this.callback = callback;
-}
+var betterStackTraces = /development/i.test(process.env.NODE_ENV) || /\bredis\b/i.test(process.env.NODE_DEBUG);
 
-function OfflineCommand (command, args, callback, call_on_write) {
+function Command (command, args, callback, call_on_write) {
     this.command = command;
     this.args = args;
+    this.buffer_args = false;
     this.callback = callback;
     this.call_on_write = call_on_write;
+    if (betterStackTraces) {
+        this.error = new Error();
+    }
 }
 
-module.exports = {
-    Command: Command,
-    OfflineCommand: OfflineCommand
-};
+module.exports = Command;

package/lib/commands.js

@@ -3,12 +3,29 @@
 var commands = require('redis-commands');
 var Multi = require('./multi');
 var RedisClient = require('../').RedisClient;
+var Command = require('./command');
+// Feature detect if a function may change it's name
+var changeFunctionName = (function () {
+    var fn = function abc () {};
+    try {
+        Object.defineProperty(fn, 'name', {
+            value: 'foobar'
+        });
+        return true;
+    } catch (e) {
+        return false;
+    }
+}());
 
 // 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) {
 
+    // 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');
+
     // Do not override existing functions
     if (!RedisClient.prototype[command]) {
         RedisClient.prototype[command.toUpperCase()] = RedisClient.prototype[command] = function () {
@@ -42,8 +59,13 @@ commands.list.forEach(function (command) {
                     arr[i] = arguments[i];
                 }
             }
-            return this.internal_send_command(command, arr, callback);
+            return this.internal_send_command(new Command(command, arr, callback));
         };
+        if (changeFunctionName) {
+            Object.defineProperty(RedisClient.prototype[command], 'name', {
+                value: commandName
+            });
+        }
     }
 
     // Do not override existing functions
@@ -79,8 +101,13 @@ commands.list.forEach(function (command) {
                     arr[i] = arguments[i];
                 }
             }
-            this.queue.push([command, arr, callback]);
+            this.queue.push(new Command(command, arr, callback));
             return this;
         };
+        if (changeFunctionName) {
+            Object.defineProperty(Multi.prototype[command], 'name', {
+                value: commandName
+            });
+        }
     }
 });

package/lib/customErrors.js

@@ -4,75 +4,43 @@ var util = require('util');
 
 function AbortError (obj) {
     Error.captureStackTrace(this, this.constructor);
-    var message;
-    Object.defineProperty(this, 'name', {
-        get: function () {
-            return this.constructor.name;
-        }
-    });
     Object.defineProperty(this, 'message', {
-        get: function () {
-            return message;
-        },
-        set: function (msg) {
-            message = msg;
-        }
+        value: obj.message || '',
+        configurable: true,
+        writable: true
     });
     for (var keys = Object.keys(obj), key = keys.pop(); key; key = keys.pop()) {
         this[key] = obj[key];
     }
-    // Explicitly add the message
-    // If the obj is a error itself, the message is not enumerable
-    this.message = obj.message;
-}
-
-function ReplyError (obj) {
-    Error.captureStackTrace(this, this.constructor);
-    var tmp;
-    Object.defineProperty(this, 'name', {
-        get: function () {
-            return this.constructor.name;
-        }
-    });
-    Object.defineProperty(this, 'message', {
-        get: function () {
-            return tmp;
-        },
-        set: function (msg) {
-            tmp = msg;
-        }
-    });
-    this.message = obj.message;
 }
 
 function AggregateError (obj) {
     Error.captureStackTrace(this, this.constructor);
-    var tmp;
-    Object.defineProperty(this, 'name', {
-        get: function () {
-            return this.constructor.name;
-        }
-    });
     Object.defineProperty(this, 'message', {
-        get: function () {
-            return tmp;
-        },
-        set: function (msg) {
-            tmp = msg;
-        }
+        value: obj.message || '',
+        configurable: true,
+        writable: true
     });
     for (var keys = Object.keys(obj), key = keys.pop(); key; key = keys.pop()) {
         this[key] = obj[key];
     }
-    this.message = obj.message;
 }
 
-util.inherits(ReplyError, Error);
 util.inherits(AbortError, Error);
 util.inherits(AggregateError, AbortError);
 
+Object.defineProperty(AbortError.prototype, 'name', {
+    value: 'AbortError',
+    // configurable: true,
+    writable: true
+});
+Object.defineProperty(AggregateError.prototype, 'name', {
+    value: 'AggregateError',
+    // configurable: true,
+    writable: true
+});
+
 module.exports = {
-    ReplyError: ReplyError,
     AbortError: AbortError,
     AggregateError: AggregateError
 };

package/lib/extendedApi.js

@@ -3,6 +3,7 @@
 var utils = require('./utils');
 var debug = require('./debug');
 var RedisClient = require('../').RedisClient;
+var Command = require('./command');
 var noop = function () {};
 
 /**********************************************
@@ -36,7 +37,7 @@ RedisClient.prototype.send_command = RedisClient.prototype.sendCommand = functio
     // but this might change from time to time and at the moment there's no good way to distinguishe 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(command, args, callback);
+        return this.internal_send_command(new Command(command, args, callback));
     }
     if (typeof callback === 'function') {
         args = args.concat([callback]); // Prevent manipulating the input array

package/lib/individualCommands.js

@@ -3,6 +3,7 @@
 var utils = require('./utils');
 var debug = require('./debug');
 var Multi = require('./multi');
+var Command = require('./command');
 var no_password_is_set = /no password is set/;
 var loading = /LOADING/;
 var RedisClient = require('../').RedisClient;
@@ -42,33 +43,34 @@ function select_callback (self, db, callback) {
 }
 
 RedisClient.prototype.select = RedisClient.prototype.SELECT = function select (db, callback) {
-    return this.internal_send_command('select', [db], select_callback(this, db, callback));
+    return this.internal_send_command(new Command('select', [db], select_callback(this, db, callback)));
 };
 
 Multi.prototype.select = Multi.prototype.SELECT = function select (db, callback) {
-    this.queue.push(['select', [db], select_callback(this._client, db, callback)]);
+    this.queue.push(new Command('select', [db], select_callback(this._client, db, callback)));
     return this;
 };
 
-function monitor_callback (self, callback) {
-    return function (err, res) {
-        if (err === null) {
-            self.monitoring = true;
-        }
-        utils.callback_or_emit(self, callback, err, res);
-    };
-}
-
 RedisClient.prototype.monitor = RedisClient.prototype.MONITOR = function monitor (callback) {
     // Use a individual command, as this is a special case that does not has to be checked for any other command
-    return this.internal_send_command('monitor', [], monitor_callback(this, callback));
+    var self = this;
+    var call_on_write = function () {
+        // Activating monitor mode has to happen before Redis returned the callback. The monitor result is returned first.
+        // Therefore we expect the command to be properly processed. If this is not the case, it's not an issue either.
+        self.monitoring = true;
+    };
+    return this.internal_send_command(new Command('monitor', [], callback, call_on_write));
 };
 
 // Only works with batch, not in a transaction
 Multi.prototype.monitor = Multi.prototype.MONITOR = function monitor (callback) {
     // Use a individual command, as this is a special case that does not has to be checked for any other command
     if (this.exec !== this.exec_transaction) {
-        this.queue.push(['monitor', [], monitor_callback(this._client, callback)]);
+        var self = this;
+        var call_on_write = function () {
+            self._client.monitoring = true;
+        };
+        this.queue.push(new Command('monitor', [], callback, call_on_write));
         return this;
     }
     // Set multi monitoring to indicate the exec that it should abort
@@ -96,11 +98,11 @@ function quit_callback (self, callback) {
     };
 }
 
-RedisClient.prototype.QUIT = RedisClient.prototype.quit = function (callback) {
+RedisClient.prototype.QUIT = RedisClient.prototype.quit = function quit (callback) {
     // TODO: Consider this for v.3
     // Allow the quit command to be fired as soon as possible to prevent it landing in the offline queue.
     // this.ready = this.offline_queue.length === 0;
-    var backpressure_indicator = this.internal_send_command('quit', [], quit_callback(this, callback));
+    var backpressure_indicator = this.internal_send_command(new Command('quit', [], quit_callback(this, callback)));
     // Calling quit should always end the connection, no matter if there's a connection or not
     this.closing = true;
     this.ready = false;
@@ -108,14 +110,14 @@ RedisClient.prototype.QUIT = RedisClient.prototype.quit = function (callback) {
 };
 
 // Only works with batch, not in a transaction
-Multi.prototype.QUIT = Multi.prototype.quit = function (callback) {
+Multi.prototype.QUIT = Multi.prototype.quit = function quit (callback) {
     var self = this._client;
     var call_on_write = function () {
         // If called in a multi context, we expect redis is available
         self.closing = true;
         self.ready = false;
     };
-    this.queue.push(['quit', [], quit_callback(self, callback), call_on_write]);
+    this.queue.push(new Command('quit', [], quit_callback(self, callback), call_on_write));
     return this;
 };
 
@@ -164,7 +166,7 @@ RedisClient.prototype.info = RedisClient.prototype.INFO = function info (section
     } else if (section !== undefined) {
         args = Array.isArray(section) ? section : [section];
     }
-    return this.internal_send_command('info', args, info_callback(this, callback));
+    return this.internal_send_command(new Command('info', args, info_callback(this, callback)));
 };
 
 Multi.prototype.info = Multi.prototype.INFO = function info (section, callback) {
@@ -174,7 +176,7 @@ Multi.prototype.info = Multi.prototype.INFO = function info (section, callback)
     } else if (section !== undefined) {
         args = Array.isArray(section) ? section : [section];
     }
-    this.queue.push(['info', args, info_callback(this._client, callback)]);
+    this.queue.push(new Command('info', args, info_callback(this._client, callback)));
     return this;
 };
 
@@ -205,7 +207,7 @@ RedisClient.prototype.auth = RedisClient.prototype.AUTH = function auth (pass, c
     this.auth_pass = pass;
     var ready = this.ready;
     this.ready = ready || this.offline_queue.length === 0;
-    var tmp = this.internal_send_command('auth', [pass], auth_callback(this, pass, callback));
+    var tmp = this.internal_send_command(new Command('auth', [pass], auth_callback(this, pass, callback)));
     this.ready = ready;
     return tmp;
 };
@@ -216,7 +218,7 @@ Multi.prototype.auth = Multi.prototype.AUTH = function auth (pass, callback) {
 
     // Stash auth for connect and reconnect.
     this.auth_pass = pass;
-    this.queue.push(['auth', [pass], auth_callback(this._client, callback)]);
+    this.queue.push(new Command('auth', [pass], auth_callback(this._client, callback)));
     return this;
 };
 
@@ -262,7 +264,7 @@ RedisClient.prototype.client = RedisClient.prototype.CLIENT = function client ()
             };
         }
     }
-    return this.internal_send_command('client', arr, callback, call_on_write);
+    return this.internal_send_command(new Command('client', arr, callback, call_on_write));
 };
 
 Multi.prototype.client = Multi.prototype.CLIENT = function client () {
@@ -307,7 +309,7 @@ Multi.prototype.client = Multi.prototype.CLIENT = function client () {
             };
         }
     }
-    this.queue.push(['client', arr, callback, call_on_write]);
+    this.queue.push(new Command('client', arr, callback, call_on_write));
     return this;
 };
 
@@ -347,7 +349,7 @@ RedisClient.prototype.hmset = RedisClient.prototype.HMSET = function hmset () {
             arr[i] = arguments[i];
         }
     }
-    return this.internal_send_command('hmset', arr, callback);
+    return this.internal_send_command(new Command('hmset', arr, callback));
 };
 
 Multi.prototype.hmset = Multi.prototype.HMSET = function hmset () {
@@ -386,7 +388,7 @@ Multi.prototype.hmset = Multi.prototype.HMSET = function hmset () {
             arr[i] = arguments[i];
         }
     }
-    this.queue.push(['hmset', arr, callback]);
+    this.queue.push(new Command('hmset', arr, callback));
     return this;
 };
 
@@ -414,7 +416,7 @@ RedisClient.prototype.subscribe = RedisClient.prototype.SUBSCRIBE = function sub
     var call_on_write = function () {
         self.pub_sub_mode = self.pub_sub_mode || self.command_queue.length + 1;
     };
-    return this.internal_send_command('subscribe', arr, callback, call_on_write);
+    return this.internal_send_command(new Command('subscribe', arr, callback, call_on_write));
 };
 
 Multi.prototype.subscribe = Multi.prototype.SUBSCRIBE = function subscribe () {
@@ -441,7 +443,7 @@ Multi.prototype.subscribe = Multi.prototype.SUBSCRIBE = function subscribe () {
     var call_on_write = function () {
         self.pub_sub_mode = self.pub_sub_mode || self.command_queue.length + 1;
     };
-    this.queue.push(['subscribe', arr, callback, call_on_write]);
+    this.queue.push(new Command('subscribe', arr, callback, call_on_write));
     return this;
 };
 
@@ -470,7 +472,7 @@ RedisClient.prototype.unsubscribe = RedisClient.prototype.UNSUBSCRIBE = function
         // Pub sub has to be activated even if not in pub sub mode, as the return value is manipulated in the callback
         self.pub_sub_mode = self.pub_sub_mode || self.command_queue.length + 1;
     };
-    return this.internal_send_command('unsubscribe', arr, callback, call_on_write);
+    return this.internal_send_command(new Command('unsubscribe', arr, callback, call_on_write));
 };
 
 Multi.prototype.unsubscribe = Multi.prototype.UNSUBSCRIBE = function unsubscribe () {
@@ -498,7 +500,7 @@ Multi.prototype.unsubscribe = Multi.prototype.UNSUBSCRIBE = function unsubscribe
         // Pub sub has to be activated even if not in pub sub mode, as the return value is manipulated in the callback
         self.pub_sub_mode = self.pub_sub_mode || self.command_queue.length + 1;
     };
-    this.queue.push(['unsubscribe', arr, callback, call_on_write]);
+    this.queue.push(new Command('unsubscribe', arr, callback, call_on_write));
     return this;
 };
 
@@ -526,7 +528,7 @@ RedisClient.prototype.psubscribe = RedisClient.prototype.PSUBSCRIBE = function p
     var call_on_write = function () {
         self.pub_sub_mode = self.pub_sub_mode || self.command_queue.length + 1;
     };
-    return this.internal_send_command('psubscribe', arr, callback, call_on_write);
+    return this.internal_send_command(new Command('psubscribe', arr, callback, call_on_write));
 };
 
 Multi.prototype.psubscribe = Multi.prototype.PSUBSCRIBE = function psubscribe () {
@@ -553,7 +555,7 @@ Multi.prototype.psubscribe = Multi.prototype.PSUBSCRIBE = function psubscribe ()
     var call_on_write = function () {
         self.pub_sub_mode = self.pub_sub_mode || self.command_queue.length + 1;
     };
-    this.queue.push(['psubscribe', arr, callback, call_on_write]);
+    this.queue.push(new Command('psubscribe', arr, callback, call_on_write));
     return this;
 };
 
@@ -582,7 +584,7 @@ RedisClient.prototype.punsubscribe = RedisClient.prototype.PUNSUBSCRIBE = functi
         // Pub sub has to be activated even if not in pub sub mode, as the return value is manipulated in the callback
         self.pub_sub_mode = self.pub_sub_mode || self.command_queue.length + 1;
     };
-    return this.internal_send_command('punsubscribe', arr, callback, call_on_write);
+    return this.internal_send_command(new Command('punsubscribe', arr, callback, call_on_write));
 };
 
 Multi.prototype.punsubscribe = Multi.prototype.PUNSUBSCRIBE = function punsubscribe () {
@@ -610,6 +612,6 @@ Multi.prototype.punsubscribe = Multi.prototype.PUNSUBSCRIBE = function punsubscr
         // Pub sub has to be activated even if not in pub sub mode, as the return value is manipulated in the callback
         self.pub_sub_mode = self.pub_sub_mode || self.command_queue.length + 1;
     };
-    this.queue.push(['punsubscribe', arr, callback, call_on_write]);
+    this.queue.push(new Command('punsubscribe', arr, callback, call_on_write));
     return this;
 };

package/lib/multi.js

@@ -2,6 +2,7 @@
 
 var Queue = require('double-ended-queue');
 var utils = require('./utils');
+var Command = require('./command');
 
 function Multi (client, args) {
     this._client = client;
@@ -20,18 +21,24 @@ function Multi (client, args) {
     }
 }
 
-function pipeline_transaction_command (self, command, args, index, cb, call_on_write) {
+function pipeline_transaction_command (self, command_obj, index) {
     // Queueing is done first, then the commands are executed
-    self._client.send_command(command, args, function (err, reply) {
+    var tmp = command_obj.callback;
+    command_obj.callback = function (err, reply) {
         // Ignore the multi command. This is applied by node_redis and the user does not benefit by it
         if (err && index !== -1) {
-            if (cb) {
-                cb(err);
+            if (tmp) {
+                tmp(err);
             }
             err.position = index;
             self.errors.push(err);
         }
-    });
+        // Keep track of who wants buffer responses:
+        // By the time the callback is called the command_obj got the buffer_args attribute attached
+        self.wants_buffers[index] = command_obj.buffer_args;
+        command_obj.callback = tmp;
+    };
+    self._client.internal_send_command(command_obj);
 }
 
 Multi.prototype.exec_atomic = Multi.prototype.EXEC_ATOMIC = Multi.prototype.execAtomic = function exec_atomic (callback) {
@@ -42,7 +49,7 @@ Multi.prototype.exec_atomic = Multi.prototype.EXEC_ATOMIC = Multi.prototype.exec
 };
 
 function multi_callback (self, err, replies) {
-    var i = 0, args;
+    var i = 0, command_obj;
 
     if (err) {
         err.errors = self.errors;
@@ -56,22 +63,22 @@ function multi_callback (self, err, replies) {
     }
 
     if (replies) {
-        while (args = self.queue.shift()) {
+        while (command_obj = self.queue.shift()) {
             if (replies[i] instanceof Error) {
                 var match = replies[i].message.match(utils.err_code);
                 // LUA script could return user errors that don't behave like all other errors!
                 if (match) {
                     replies[i].code = match[1];
                 }
-                replies[i].command = args[0].toUpperCase();
-                if (typeof args[2] === 'function') {
-                    args[2](replies[i]);
+                replies[i].command = command_obj.command.toUpperCase();
+                if (typeof command_obj.callback === 'function') {
+                    command_obj.callback(replies[i]);
                 }
             } else {
                 // If we asked for strings, even in detect_buffers mode, then return strings:
-                replies[i] = self._client.handle_reply(replies[i], args[0], self.wants_buffers[i]);
-                if (typeof args[2] === 'function') {
-                    args[2](null, replies[i]);
+                replies[i] = self._client.handle_reply(replies[i], command_obj.command, self.wants_buffers[i]);
+                if (typeof command_obj.callback === 'function') {
+                    command_obj.callback(null, replies[i]);
                 }
             }
             i++;
@@ -98,30 +105,16 @@ Multi.prototype.exec_transaction = function exec_transaction (callback) {
     self.callback = callback;
     self._client.cork();
     self.wants_buffers = new Array(len);
-    pipeline_transaction_command(self, 'multi', [], -1);
+    pipeline_transaction_command(self, new Command('multi', []), -1);
     // Drain queue, callback will catch 'QUEUED' or error
     for (var index = 0; index < len; index++) {
         // The commands may not be shifted off, since they are needed in the result handler
-        var command_obj = self.queue.get(index);
-        var command = command_obj[0];
-        var cb = command_obj[2];
-        var call_on_write = command_obj.length === 4 ? command_obj[3] : undefined;
-        // Keep track of who wants buffer responses:
-        if (self._client.options.detect_buffers) {
-            self.wants_buffers[index] = false;
-            for (var i = 0; i < command_obj[1].length; i += 1) {
-                if (command_obj[1][i] instanceof Buffer) {
-                    self.wants_buffers[index] = true;
-                    break;
-                }
-            }
-        }
-        pipeline_transaction_command(self, command, command_obj[1], index, cb, call_on_write);
+        pipeline_transaction_command(self, self.queue.get(index), index);
     }
 
-    self._client.internal_send_command('exec', [], function (err, replies) {
+    self._client.internal_send_command(new Command('exec', [], function (err, replies) {
         multi_callback(self, err, replies);
-    });
+    }));
     self._client.uncork();
     return !self._client.should_buffer;
 };
@@ -144,16 +137,17 @@ Multi.prototype.exec = Multi.prototype.EXEC = Multi.prototype.exec_batch = funct
     var len = self.queue.length;
     var index = 0;
     var command_obj;
+    if (len === 0) {
+        utils.reply_in_order(self._client, callback, null, []);
+        return !self._client.should_buffer;
+    }
     self._client.cork();
     if (!callback) {
         while (command_obj = self.queue.shift()) {
-            self._client.internal_send_command(command_obj[0], command_obj[1], command_obj[2], (command_obj.length === 4 ? command_obj[3] : undefined));
+            self._client.internal_send_command(command_obj);
         }
         self._client.uncork();
         return !self._client.should_buffer;
-    } else if (len === 0) {
-        utils.reply_in_order(self._client, callback, null, []);
-        return !self._client.should_buffer;
     }
     var callback_without_own_cb = function (err, res) {
         if (err) {
@@ -175,18 +169,15 @@ Multi.prototype.exec = Multi.prototype.EXEC = Multi.prototype.exec_batch = funct
     };
     self.results = [];
     while (command_obj = self.queue.shift()) {
-        var command = command_obj[0];
-        var call_on_write = command_obj.length === 4 ? command_obj[3] : undefined;
-        var cb;
-        if (typeof command_obj[2] === 'function') {
-            cb = batch_callback(self, command_obj[2], index);
+        if (typeof command_obj.callback === 'function') {
+            command_obj.callback = batch_callback(self, command_obj.callback, index);
         } else {
-            cb = callback_without_own_cb;
+            command_obj.callback = callback_without_own_cb;
         }
         if (typeof callback === 'function' && index === len - 1) {
-            cb = last_callback(cb);
+            command_obj.callback = last_callback(command_obj.callback);
         }
-        this._client.internal_send_command(command, command_obj[1], cb, call_on_write);
+        this._client.internal_send_command(command_obj);
         index++;
     }
     self._client.uncork();

package/lib/utils.js

@@ -1,7 +1,5 @@
 'use strict';
 
-var RawObject = require('./rawObject');
-
 // hgetall converts its replies to an Object. If the reply is empty, null is returned.
 // These function are only called with internal data and have therefore always the same instanceof X
 function replyToObject (reply) {
@@ -9,7 +7,7 @@ function replyToObject (reply) {
     if (reply.length === 0 || !(reply instanceof Array)) {
         return null;
     }
-    var obj = new RawObject();
+    var obj = {};
     for (var i = 0; i < reply.length; i += 2) {
         obj[reply[i].toString('binary')] = reply[i + 1];
     }
@@ -59,14 +57,18 @@ function clone (obj) {
         var elems = Object.keys(obj);
         var elem;
         while (elem = elems.pop()) {
-            // Accept camelCase options and convert them to snack_case
-            var snack_case = elem.replace(/[A-Z][^A-Z]/g, '_$&').toLowerCase();
+            if (elem === 'tls') { // special handle tls
+                copy[elem] = obj[elem];
+                continue;
+            }
+            // Accept camelCase options and convert them to snake_case
+            var snake_case = elem.replace(/[A-Z][^A-Z]/g, '_$&').toLowerCase();
             // If camelCase is detected, pass it to the client, so all variables are going to be camelCased
             // There are no deep nested options objects yet, but let's handle this future proof
-            if (snack_case !== elem.toLowerCase()) {
+            if (snake_case !== elem.toLowerCase()) {
                 camelCase = true;
             }
-            copy[snack_case] = clone(obj[elem]);
+            copy[snake_case] = clone(obj[elem]);
         }
         return copy;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redis",
-  "version": "2.6.0-2",
+  "version": "2.6.3",
   "description": "Redis client library",
   "keywords": [
     "database",
@@ -21,12 +21,13 @@
     "coverage": "nyc report --reporter=html",
     "benchmark": "node benchmarks/multi_bench.js",
     "test": "nyc --cache mocha ./test/*.js ./test/commands/*.js --timeout=8000",
-    "posttest": "eslint . --fix"
+    "posttest": "eslint . --fix && npm run coverage",
+    "compare": "node benchmarks/diff_multi_bench_output.js beforeBench.txt afterBench.txt"
   },
   "dependencies": {
     "double-ended-queue": "^2.1.0-0",
     "redis-commands": "^1.2.0",
-    "redis-parser": "^1.3.0"
+    "redis-parser": "^2.0.0"
   },
   "engines": {
     "node": ">=0.10.0"
@@ -38,7 +39,7 @@
     "eslint": "^2.5.0",
     "metrics": "^0.1.9",
     "mocha": "^2.3.2",
-    "nyc": "^6.0.0",
+    "nyc": "^8.3.0",
     "tcp-port-used": "^0.1.2",
     "uuid": "^2.0.1",
     "win-spawn": "^2.0.0"

package/lib/rawObject.js

@@ -1,8 +0,0 @@
-'use strict';
-
-// Using a predefined object with this prototype is faster than calling `Object.create(null)` directly
-// This is needed to make sure `__proto__` and similar reserved words can be used
-function RawObject () {}
-RawObject.prototype = Object.create(null);
-
-module.exports = RawObject;