Library to interact with residue server seamlessly. 

amrayn

residue

muflihun

 - `loadConfiguration` now accepts object

- Do not send multiple touch requests when one is pending

- Changed verbose signature from `msg, level` to `level, msg`

- Use of `CHECK_TOKENS` server flag to reduce overhead of pulling token when not needed

- Re-estabilish connection if remote disconnected and dispatch all the logs

- Fixed issue with token retrieving when client is dead

- Fixed issue with pinging client when `client_age` < 60

- Fixed issue with key when client created using different key size

- Fixed issue with token retrieving using default access code

- Use `path` module to resolve relative file paths

- Ability to specify public key for encrypted private keys

- Fixed issues with getting correct filename, line number and function name

- Added `loadConfiguration` to load configurations from json file

- Obtaining token race-condition issue #26

- Fixed issue with verifying token with `0` life

- Updated API to use configurations as C++ API

- Send server flags with final connection #14

- Support sending plain log requests in lib #13

  "description": "Library to interact with residue server seamlessly.",

    "test": "echo \"No tests available\" && exit 1"

    "url": "git+https://github.com/muflihun/residue-node.git"

  "author": "Muflihun Labs <info@muflihun.com>",

    "url": "https://github.com/muflihun/residue-node/issues"

  "homepage": "https://github.com/muflihun/residue-node#readme",

[![Version](https://img.shields.io/npm/v/residue.svg)](https://www.npmjs.com/package/residue)

[![GitHub license](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/muflihun/residue-node/blob/master/LICENSE)

[![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/MuflihunDotCom/25)

A very simple, secure Node.js library to interact with residue seamlessly.

This module provides interface for connecting and interacting with residue server seamlessly, means, once you are connected this module takes care of expired tokens and clients and keep itself updated with latest tokens and ping server when needed to stay alive.

This library depends on following native modules, without them library will not work:

 * [Path Module](https://nodejs.org/api/path.html)

 * [File System Module](https://nodejs.org/api/fs.html)

 * [Crypto Module](https://nodejs.org/api/crypto.html)

 * [ZLib Module](https://nodejs.org/api/zlib.html)

 * [Net Module](https://nodejs.org/api/net.html)

 * [Util Module](https://nodejs.org/api/util.html)

Connects application to residue using params. If options is not specified, you should use `loadConfiguration` to load the options

    url: "<host_where_residue_server_is_listening>:<residue_connection_port>",

    application_id: <app_name [optional]>,

    rsa_key_size: <key_size_for_initial_final_key_transmission [optional]>,

    utc_time: <whether_to_use_UTC_time [optional]>,

    time_offset: <time_offset_in_seconds [optional]>,

    client_id: <client_id_that_server_knows_you_as [optional]>,

    client_private_key: <full_path_of_private_key> [must be provided with client_id],

    client_public_key: <full_path_of_public_key> [must be provided with client_id],

    client_key_secret: <secret (passphrase) for encrypted private key if any>,

    client_key_secret: <base16 encoded secret (passphrase) for encrypted private key if any>,

    server_public_key: <full_path_of_server_public_key>

Please refer to [`loadConfiguration`](https://muflihun.github.io/residue/docs/class_residue.html#a8292657c93a775b6cbf22c6d4f1166f4) in our C++ library's documentation for more details.

Loads configurations / options via json file. Returns true if successfully loaded, otherwise false.

This does not verify the options. Options are validated in `connect()` function

Returns logger class for logging interface

var logger = residue.getLogger('sample-app');

if (residue.loadConfiguration(confFile)) {

var person = { 'name': 'Adam', 'age': 960, }

You can check out [sample client apps](https://github.com/muflihun/residue-node/blob/master/samples) for practical use of this package.

Licensed under the Apache License, Version 2.0 (the "License");

you may not use this file except in compliance with the License.

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software

distributed under the License is distributed on an "AS IS" BASIS,

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

See the License for the specific language governing permissions and

// Official Node.js client library for Residue logging server

// This module provides interface for connecting and interacting with

// residue server seamlessly. Once you are connected this module

// takes care of lost connections, expired clients

// and keep itself updated with parameters and touch server when 

// https://github.com/muflihun/residue-node

    console.log('residue package requires crypto (https://nodejs.org/api/crypto.html). It is disabled in your version of node!');

    // user provided options for seamless connection

    //   client_id, age, date_created, key, logging_port

    // whether connected to the server or not

Params.locks[Params.connection_socket.address().port] = false;

Params.locks[Params.logging_socket.address().port] = false;

// Various connection types accepted by the server

// Various logging levels accepted by the server

                    key: fs.readFileSync(path.resolve(Params.options.client_private_key)).toString(),

                    passphrase: Params.options.client_key_secret || null,

                    passphrase: Params.options.client_key_secret

                        ? new Buffer(Params.options.client_key_secret, 'hex').toString('utf-8') : null,

                    padding: crypto.constants.RSA_PKCS1_PADDING,

            if (typeof Params.options.client_public_key !== 'undefined') {

                Params.rsa_key.publicKey.key = fs.readFileSync(path.resolve(Params.options.client_public_key)).toString();

                if (Params.rsa_key.privateKey.passphrase === null) {

                    Params.rsa_key.publicKey.key = Utils.extractPublicKey(Params.rsa_key.privateKey);

                    throw 'ERROR: You specified client_key_secret and did not provide client_public_key. We cannot extract public-key for encrypted private keys. Please provide public key manually';

            Utils.vLog(8, 'Known client...');

        if (typeof Params.options.server_public_key !== 'undefined') {

                    key: fs.readFileSync(path.resolve(Params.options.server_public_key)).toString(),

        Utils.log('Intializing connection...');

        Params.connection_socket.connect(Params.options.connect_port, Params.options.host, () => {

                _t: Utils.getTimestamp(),

                type: ConnectType.Connect,

            if (Params.rsa_key.isGenerated) {

                request.rsa_public_key = Utils.base64Encode(Params.rsa_key.publicKey.key);

                request.client_id = Params.options.client_id;

            let r = JSON.stringify(request);

            if (Params.server_rsa_key !== null) {

                r = Utils.encryptRSA(r, Params.server_rsa_key.publicKey);

            const fullReq = r + PACKET_DELIMITER;

            Params.connection_socket.write(fullReq);

        Utils.log('Error occurred while connecting to residue server');

    Params.logging_socket_connected = false;

            if (Params.connection_socket.destroyed) {

                Utils.log('Disconnecting gracefully...');

                Params.logging_socket.end();

                Utils.log('Disconnecting...');

                // Following will call 'close' -> disconnect -> gracefully close

                Params.connection_socket.end();

// Get location of callstack in <file>:<line> format

const getSourceLocation = (splitChar) => (new Error).stack.split('\n')[4].replace(' at ', '').trim().split(splitChar);

const getSourceFile = () => getSourceLocation(':')[0];

const getSourceLine = () => parseInt(getSourceLocation(':')[1]);

    const parts = getSourceLocation(' ');

// Logger interface for user to send log messages to server

    this.info = (format, ...args) => sendLogRequest(LoggingLevels.Info, this.id, getSourceFile(), getSourceLine(), getSourceFunc(), 0, undefined, format, ...args);

    this.error = (format, ...args) => sendLogRequest(LoggingLevels.Error, this.id, getSourceFile(), getSourceLine(), getSourceFunc(), 0, undefined, format, ...args);

		# Change Log

		## [2.1.0]
		- Private key uses hex

		## [2.0.1]
		@@ -4,0 +7,0 @@ - Compatibility with server 2.0.0

		{
		"name": "residue",
		"version": "2.0.1",
		"version": "2.1.0",
		"description": "Library to interact with residue server seamlessly.",
		@@ -5,0 +5,0 @@ "main": "src/residue.js",

		@@ -32,7 +32,2 @@ ﷽
		url: "<host_where_residue_server_is_listening>:<residue_connection_port>",
		access_codes: [
		{
		... logger_id and code
		}
		],
		application_id: <app_name [optional]>,
		@@ -45,3 +40,3 @@ rsa_key_size: <key_size_for_initial_final_key_transmission [optional]>,
		client_public_key: <full_path_of_public_key> [must be provided with client_id],
		client_key_secret: <secret (passphrase) for encrypted private key if any>,
		client_key_secret: <base16 encoded secret (passphrase) for encrypted private key if any>,
		server_public_key: <full_path_of_server_public_key>
		@@ -71,2 +66,7 @@ }

		// ALTERNATIVELY
		residue.connect({
		url: ...
		});

		logger.info('simple log');
		@@ -73,0 +73,0 @@

		@@ -541,3 +541,4 @@ //
		key: fs.readFileSync(path.resolve(Params.options.client_private_key)).toString(),
		passphrase: Params.options.client_key_secret \|\| null,
		passphrase: Params.options.client_key_secret
		? new Buffer(Params.options.client_key_secret, 'hex').toString('utf-8') : null,
		padding: crypto.constants.RSA_PKCS1_PADDING,
		@@ -544,0 +545,0 @@ },

Improved metrics