New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More
Socket
Sign inDemoInstall
Socket

heka

Package Overview
Dependencies
Maintainers
1
Versions
6
Alerts
File Explorer

Advanced tools

Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

heka - npm Package Compare versions

Comparing version 0.1.1 to 0.2.0

message/helpers.js

109

client.js

@@ -13,13 +13,27 @@ /*

* Rob Miller (rmiller@mozilla.com)
* Victor Ng (vng@mozilla.com)
*
***** END LICENSE BLOCK *****
*/
"use strict"
"use strict";
var Senders = require('./senders/index');
var _ = require('underscore');
var superscore = require('superscore');
var config = require('./config');
var env_version = '0.8';
var message = require('./message');
var helpers = require('./message/helpers');
var toArrayBuffer = helpers.toArrayBuffer;
var Field = message.Field;
var os = require('os');
var Senders = require('./senders/index');
var _ = require('underscore');
var ByteBuffer = require('bytebuffer');
var uuid = require('./uuid');
var compute_oid_uuid = uuid.compute_oid_uuid;
var helpers = require('./message/helpers');
var dict_to_fields = helpers.dict_to_fields;
// Put a namespace around RFC 3164 syslog messages

@@ -37,22 +51,25 @@ var SEVERITY = {

function IsoDateString(d) {
function zeroFill(number, width)
{
width -= number.toString().length;
if ( width > 0 )
{
return new Array( width + (/\./.test( number ) ? 2 : 1) ).join( '0' ) + number;
}
return number + ""; // always return a string
}
var PB_NAMETYPE_TO_INT = {'STRING': 0,
'BYTES': 1,
'INTEGER': 2,
'DOUBLE': 3,
'BOOL': 4};
return d.getUTCFullYear() + '-'
+ zeroFill(d.getUTCMonth() + 1, 2) + '-'
+ zeroFill(d.getUTCDate(), 2) + 'T'
+ zeroFill(d.getUTCHours(), 2) + ':'
+ zeroFill(d.getUTCMinutes(), 2) + ':'
+ zeroFill(d.getUTCSeconds(), 2) + "."
+ zeroFill(d.getUTCMilliseconds() * 1000, 6) + 'Z'
var PB_TYPEMAP = {0: 'STRING',
1: 'BYTES',
2: 'INTEGER',
3: 'DOUBLE',
4: 'BOOL'};
var PB_FIELDMAP = {0: 'value_string',
1: 'value_bytes',
2: 'value_integer',
3: 'value_double',
4: 'value_bool'};
function DateToNano(d) {
return d.getTime() * 1000000;
}
var HekaClient = function(sender, logger, severity, disabledTimers, filters)

@@ -68,3 +85,3 @@ {

this.logger = typeof(logger) != 'undefined' ? logger : '';
this.severity = typeof(severity) != 'undefined' ? severity : 6;
this.severity = typeof(severity) != 'undefined' ? severity : SEVERITY.INFORMATIONAL;
this.disabledTimers = typeof(disabledTimers) != 'undefined' ? disabledTimers : [];

@@ -91,4 +108,4 @@ this.filters = typeof(filters) != 'undefined' ? filters : [];

HekaClient.prototype.heka = function(type, opts) {
// opts = timestamp, logger, severity, payload, fields
if (opts === undefined) opts = {};
if (opts.timestamp === undefined) opts.timestamp = new Date();

@@ -99,22 +116,32 @@ if (opts.logger === undefined) opts.logger = this.logger;

if (opts.fields === undefined) opts.fields = {};
if (opts.timestamp instanceof Date) {
opts.timestamp = IsoDateString(opts.timestamp);
};
if (opts.pid === undefined) opts.pid = this.pid;
if (opts.hostname === undefined) opts.hostname = this.hostname;
var msg = new message.Message();
msg.timestamp = DateToNano(opts.timestamp);
var fullMsg = {'type': type, 'timestamp': opts.timestamp,
'logger': opts.logger, 'severity': opts.severity,
'payload': opts.payload, 'fields': opts.fields,
'env_version': env_version,
'heka_pid': opts.pid,
'heka_hostname': opts.hostname
};
this._sendMessage(fullMsg);
msg.type = type;
msg.logger = opts.logger;
msg.severity = opts.severity;
msg.payload = opts.payload;
var fields = dict_to_fields(opts.fields);
for (var i = 0; i < fields.length; i++) {
msg.fields.push(fields[i]);
}
msg.env_version = env_version;
msg.pid = opts.pid;
msg.hostname = opts.hostname;
msg.uuid = '0000000000000000';
var msg_encoded = msg.encode();
var raw_uuid = new Buffer(compute_oid_uuid(msg_encoded.toBuffer()), "hex");
msg.uuid = ByteBuffer.wrap(toArrayBuffer(raw_uuid));
this._sendMessage(msg);
};
HekaClient.prototype.addMethod = function(name, method, override) {
if (typeof(method) !== 'function') {
if (typeof method !== 'function') {
throw new Error('`method` argument must be a function');

@@ -162,3 +189,4 @@ };

HekaClient.prototype.timer = function(fn, name, opts) {
// opts = timestamp, logger, severity, fields, rate
if (opts === undefined) opts = {};
if (opts.rate === undefined) opts.rate = 1;

@@ -181,5 +209,2 @@ var NoOpTimer = function() {

//
//
if (opts === undefined) opts = {};
var currentClient = this;

@@ -231,3 +256,7 @@

exports.IsoDateString = IsoDateString;
/***************************/
exports.DateToNano = DateToNano;
exports.HekaClient = HekaClient;

@@ -234,0 +263,0 @@ exports.clientFromJsonConfig = config.clientFromJsonConfig;

@@ -20,3 +20,6 @@ /*

var globalConfig = {};
var resolver = require('./resolver');
var resolveName = resolver.resolveName;
var getattr = function(obj, attr, defaultValue) {

@@ -28,32 +31,4 @@ defaultValue = typeof(defaultValue) !== 'undefined' ? defaultValue : {};

/*
* Fetch a module attribute by name and return the actual object (usually
* a function) to which the name refers.
*
* @param name: String referring to the callable. Should consist of a module
* name (can be a bare name or a file path, anything that will
* work with `require`) and an exported module attribute name
* separated by a colon. For example, this function itself would
* be specified by './config:resolveName'.
*/
var resolveName = function(name) {
var pieces = name.split(':');
var module = require(pieces[0]);
var fn_path = pieces[1].split(".");
var fn = null;
fn = module[fn_path.shift()];
for (; fn_path.length > 0;) {
fn = fn[fn_path.shift()];
}
if (fn === undefined) {
var msg = "ERROR loading: ["+pieces[0]+":" + pieces[1] + "]. Make sure you've exported it properly.";
throw new Error(msg);
}
return fn;
};
var getGlobalConfig = function() {

@@ -60,0 +35,0 @@ return globalConfig;

{
"author": "Rob Miller <rmiller@mozilla.com>",
"name": "heka",
"description": "Metrics logging",
"version": "0.1.1",
"description": "A node.js client for Mozilla's Heka logging server",
"version": "0.2.0",
"homepage": "https://github.com/mozilla-services/heka-node",

@@ -12,2 +12,6 @@ "repository": {

"main": "./client.js",
"files": ["protobuf/*.proto",
"message/*.js",
"senders/*.js",
"*.js"],
"engines": {

@@ -17,15 +21,13 @@ "node": ">=0.10.0"

"dependencies": {
"underscore": ">=1.4.2"
"protobufjs": ">=0.12.8",
"underscore": ">=1.4.2",
"superscore": ">=0.3.4"
},
"optionalDependencies": {
"msgpack":">=0.1.5",
"restify":">=1.4.4"
},
"devDependencies": {
"jasmine-node": ">=1.0.13",
"jasmine-node": ">=1.6.0",
"horaa": ">=0.1.1alpha"
},
"scripts": {
"test": "jasmine-node tests"
"test": "jasmine-node tests"
}
}

@@ -19,3 +19,14 @@ /*

var encoders = require('./encoders');
var resolver = require('../resolver');
var message = require('../message');
var crypto = require('crypto');
var ByteBuffer = require('bytebuffer');
var helpers = require('../message/helpers');
var toArrayBuffer = helpers.toArrayBuffer;
var resolveName = resolver.resolveName;
var HASHNAME_TO_ENUM = { 'sha1': message.Header.HmacHashFunction.SHA1,
'md5': message.Header.HmacHashFunction.MD5};
var abstractSender = function() {

@@ -27,17 +38,70 @@ /*

*/
this.init = function(encoder) {
if (typeof(encoder) === 'function') {
this.encoder = encoder;
} else {
this.init = function(encoder, hmc) {
if (typeof encoder === 'string') {
this.encoder = resolveName(encoder);
}
if (encoder === undefined) {
this.encoder = encoders.jsonEncoder;
};
if (hmc === undefined) {
this.hmc = null;
} else {
this.hmc = hmc;
}
};
this.buildHeader = function(msg, msg_length) {
var header = new message.Header();
header.message_encoding = this.encoder.encoder_type;
header.message_length = msg_length;
if (this.hmc != null) {
var hmac = crypto.createHmac(this.hmc.hash_function, this.hmc.key);
hmac.update(msg.encode().toBuffer());
header.hmac_signer = this.hmc.signer;
header.hmac_key_version = this.hmc.key_version;
// TODO: handle the case where we don't have a match to
// the hash function
header.hmac_hash_function = HASHNAME_TO_ENUM[this.hmc.hash_function];
header.hmac = ByteBuffer.wrap(toArrayBuffer(new Buffer(hmac.digest('hex'), 'hex')));
}
return header;
};
this.sendMessage = function(msg) {
output = this.encoder(msg);
/*
* Wire format is:
*
* 1 byte : RECORD_SEPARATOR
* 1 byte : HEADER_LENGTH
* N bytes : header
* 1 byte : UNIT_SEPARATOR
* N bytes : messsage bytes
*/
msg_buff = this.encoder.encode(msg);
header = this.buildHeader(msg, msg_buff.length);
var header_buff = header.encode().toBuffer();
var buff = new Buffer(2);
buff.writeUInt8(message.RECORD_SEPARATOR, 0);
buff.writeUInt8(header_buff.length, 1);
var unit_buff = new Buffer(1);
unit_buff.writeUInt8(message.UNIT_SEPARATOR, 0);
var result_buff = Buffer.concat([buff, header_buff, unit_buff, msg_buff])
// The implementation of send_msg should *not* alter the
// content in anyway prior to transmission. This ensures that
// switching to an alternate encoder is always safe.
this._send_msg(output);
this._send_msg(result_buff);
};

@@ -44,0 +108,0 @@

@@ -19,5 +19,5 @@ /*

var StdoutSender = function(encoder) {
var StdoutSender = function(encoder, hmc) {
this.stream = process.stdout;
this.init(encoder);
this.init(encoder, hmc);

@@ -33,9 +33,10 @@ this._send_msg = function(text) {

var encoder = config['encoder'];
return new StdoutSender(encoder);
var hmc = config['hmc'];
return new StdoutSender(encoder, hmc);
};
var FileSender = function(filePath, encoder) {
var FileSender = function(filePath, encoder, hmc) {
this.stream = fs.createWriteStream(filePath);
this.init(encoder);
this.init(encoder, hmc);

@@ -48,7 +49,30 @@ this._send_msg = function(text) {

var fileSenderFactory = function(filePath, encoder) {
return new FileSender(filePath, encoder);
var fileSenderFactory = function(sender_config) {
var filePath = sender_config['filePath'];
var encoder = sender_config['encoder'];
var hmc = sender_config['hmc'];
return new FileSender(filePath, encoder, hmc);
};
var DebugSender = function(encoder, hmc) {
this.init(encoder, hmc);
this.msgs = [];
this._send_msg = function(text) {
this.msgs.push(text);
}
};
base.abstractSender.call(DebugSender.prototype);
var debugSenderFactory = function(config) {
var config = typeof config !== 'undefined' ? config : {};
var encoder = config['encoder'];
var hmc = config['hmc'];
return new DebugSender(encoder, hmc);
};
exports.fileSenderFactory = fileSenderFactory;
exports.stdoutSenderFactory = stdoutSenderFactory;
exports.debugSenderFactory = debugSenderFactory;

@@ -18,19 +18,96 @@ /*

var Header = require('../message').Header;
try
{
var msgpack = require('msgpack');
} catch(err) {
var msgpack = null;
/*
* Encoders are classes implement an encode(msg) method and
* serialize to a node.js Buffer.
*
* They must also export an attribute `encoder_type` which
* provides a lookup value into the ProtocolBuffer definition
* in Header.MessageEncoding
*
*/
var PB_NAMETYPE_TO_INT = {'STRING': 0,
'BYTES': 1,
'INTEGER': 2,
'DOUBLE': 3,
'BOOL': 4};
var PB_TYPEMAP = {0: 'STRING',
1: 'BYTES',
2: 'INTEGER',
3: 'DOUBLE',
4: 'BOOL'};
var PB_FIELDMAP = {0: 'value_string',
1: 'value_bytes',
2: 'value_integer',
3: 'value_double',
4: 'value_bool'};
var JSONEncoder = function() {
this.setup();
}
var jsonEncoder = function(data) {
return JSON.stringify(data) + "\n";
JSONEncoder.prototype.setup = function() {
this.encoder_type = Header.MessageEncoding.JSON;
}
var msgpackEncoder = function(data) {
return msgpack.pack(data);
JSONEncoder.prototype.encode = function(msg) {
jdata = {}
jdata['uuid'] = new Buffer(msg.uuid).toString('base64');
jdata['timestamp'] = msg.timestamp;
jdata['type'] = msg.type;
jdata['logger'] = msg.logger;
jdata['severity'] = msg.severity;
jdata['payload'] = msg.payload;
jdata['env_version'] = msg.env_version;
jdata['pid'] = msg.pid;
jdata['hostname'] = msg.hostname;
jdata['fields'] = [];
for (var i = 0; i < msg.fields.length; i++) {
var f = msg.fields[i];
var field_dict = {'value_type': f.value_type, 'value_format': 0};
if (f.value_string.length !== 0) {
field_dict['value_string'] = [f.value_string[0]];
jdata['fields'].push(field_dict);
} else if (f.value_bytes.length !== 0) {
field_dict['value_bytes'] = [(new Buffer(f.value_bytes[0])).toString('base64')];
jdata['fields'].push(field_dict);
} else if (f.value_integer.length !== 0) {
field_dict['value_integer'] = [f.value_integer[0]];
jdata['fields'].push(field_dict);
} else if (f.value_double.length !== 0) {
field_dict['value_double'] = [f.value_double[0]];
jdata['fields'].push(field_dict);
} else if (f.value_bool.length !== 0) {
field_dict['value_bool'] = [f.value_bool[0]];
jdata['fields'].push(field_dict);
}
}
var data = JSON.stringify(jdata)
return new Buffer(data);
}
exports.msgpackEncoder = msgpackEncoder;
exports.jsonEncoder = jsonEncoder;
var ProtoBufEncoder = function() {
this.setup();
}
ProtoBufEncoder.prototype.setup = function() {
this.encoder_type = Header.MessageEncoding.PROTOCOL_BUFFER;
}
ProtoBufEncoder.prototype.encode = function(msg) {
return msg.encode().toBuffer()
}
exports.jsonEncoder = new JSONEncoder();
exports.protobufEncoder = new ProtoBufEncoder();

@@ -17,9 +17,8 @@ /*

"use strict";
var zmq = require('./zmq.js');
var dev = require('./dev.js');
var udp = require('./udp.js');
exports.debugSenderFactory = dev.debugSenderFactory;
exports.fileSenderFactory = dev.fileSenderFactory;
exports.stdoutSenderFactory = dev.stdoutSenderFactory;
exports.udpSenderFactory = udp.udpSenderFactory;
exports.zmqPubSenderFactory = zmq.zmqPubSenderFactory;

@@ -22,4 +22,4 @@ /*

var UdpSender = function(host, port, encoder) {
this.init(encoder);
var UdpSender = function(host, port, encoder, hmc) {
this.init(encoder, hmc);

@@ -51,4 +51,3 @@ if (!Array.isArray(host))

this._send_msg = function(text) {
var message = new Buffer(text);
this._send_msg = function(buffer) {
var client = this.dgram.createSocket("udp4");

@@ -59,3 +58,3 @@

var port = elem[1];
client.send(message, 0, message.length, port, host, function(err, bytes) {
client.send(buffer, 0, buffer.length, port, host, function(err, bytes) {
client.close();

@@ -85,8 +84,13 @@ });

var ports = sender_config['ports'];
var encoder = sender_config['encoder'];
var hmc = sender_config['hmc'];
if ((hosts == null) || (ports == null)) {
throw new Error("Invalid host/port combination: ["+hosts+"] ["+ports+"]");
}
return new UdpSender(hosts, ports);
var sender = new UdpSender(hosts, ports, encoder, hmc);
return sender;
};
exports.udpSenderFactory = udpSenderFactory;
SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

Packages

npm

Stay in touch

Get open source security insights delivered straight into your inbox.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc