fluent-plugin-websocket 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88b467a1b71ca69b8a5788e2b8eaf77dc2757e5d
-  data.tar.gz: d875ee07c22e50bca910a3fde58114ada7cee4ba
+  metadata.gz: bed9989f3203afca2a0ecac1ecd6d0155aa6b061
+  data.tar.gz: 9fe57af129239dd41520445f6f3d5b0e5f90b71b
 SHA512:
-  metadata.gz: 5a94849d7c1120d52cb8ba89f554de622fb7027989e426d76ab103e01ea6021bd1631db2914e09112bad06313f4af63e35e62a78affca0ffceb1e29b060db2db
-  data.tar.gz: 9373a773cdf5f4cd5bdc0e1d04738f18b2315c3bafcebe72d933a6fd83b5f2a984c298da0a61aebbf571b792078e83374355ea15f6b6cf63da15db1058ffed6e
+  metadata.gz: 49300703aa75c86e1a571a5e1bc527bacf735916e8d3c85718e0f400756b920071657528263152248a2b678b546e9c1cd260f062ef2bda49afbbd09cbf49f687
+  data.tar.gz: 1446c1902d16db79f4c499c0d68afb5c9e86b0ad418d87073c0acc302652a51c16287cbe29bfe506547c28bbe3fd1c275f629c012c196c8a93701dfbdcfb16a8

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2013 IZAWA Tetsu (@moccos)
+Copyright (c) 2013 Tetsu Izawa (@moccos)
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

data/README.rdoc

@@ -1,4 +1,5 @@
-= Fluent::Plugin::Websocket
+= fluent-plugin-websocket
+{https://badge.fury.io/rb/fluent-plugin-websocket.svg}[https://badge.fury.io/rb/fluent-plugin-websocket]
 
 Fluentd websocket output plugin.
 
@@ -10,17 +11,16 @@ In the current version, emitted data will be broadcasted to the all connected cl
 
     gem install fluent-plugin-websocket
 
-This plugin depends on {*em-websocket*}[https://github.com/igrigorik/em-websocket].
-
 == Configuration
     <match foo.**>
       type websocket
-      host 192.168.1.1    # default: 0.0.0.0 (ANY)
-      port 8080           # default: 8080
-      use_msgpack false   # default: false
-      add_time false      # default: false
-      add_tag true        # default: true
+      host 192.168.1.1      # default: 0.0.0.0 (ANY)
+      port 8080             # default: 8080
+      use_msgpack false     # default: false
+      add_time false        # default: false
+      add_tag true          # default: true
       buffered_messages 100 # default: 0
+      token SomeToken       # default: nil
     </match>
 
 * *host*: WebSocket server IP address.
@@ -29,6 +29,7 @@ This plugin depends on {*em-websocket*}[https://github.com/igrigorik/em-websocke
 * <b>add_time</b>: Add timestamp to the data.
 * <b>add_tag</b>: Add fluentd tag to the data.
 * <b>buffered_messages</b>: The number of messages to be buffered. The new connection receives them.
+* <b>token</b>: Authentication token. Passed as get param. If set to nil, authentication is disabled.
 
 If there are no websocket connections, this plugin silently discards data. You may use <em>out_copy</em> plugin like this:
 
@@ -74,23 +75,33 @@ Extract data by {msgpack.js}[https://github.com/msgpack/msgpack-javascript].
       ...
     }
 
-== Contributing
+=== Authentication and filtering
+
+    curl --include \
+         --no-buffer \
+         --header "Connection: Upgrade" \
+         --header "Upgrade: websocket" \
+         --header "Host: 127.0.0.1:8080" \
+         --header "Origin: http://127.0.0.1:8080" \
+         --header "Sec-WebSocket-Key: SGVabG8sIHOvcmxDIQ==" \
+         --header "Sec-WebSocket-Version: 13" \
+         "http://127.0.0.1:8888/?foo=bar&token=MyT0ken"
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+* If token setting in config file is not nil, websocket server checks _token_ parameter
+* Client will receive data which include \{"foo": "bar"\}
 
-== Recent changes
-* 0.1.7 Add message buffering. (Thanks to {SebastianOsuna}[https://github.com/SebastianOsuna])
+== Changelogs
+* 0.1.8 Add authentication and filtering
+* 0.1.7 Add message buffering.
 * 0.1.6 Added license to gemspec.
-* 0.1.5 Fixed dependencies. (Thanks to {ca-gacky}[https://github.com/ca-gacky])
-* 0.1.4 Changed json parser to yajl. (Thanks to {Kogarasi}[https://github.com/Kogarasi])
+* 0.1.5 Fixed dependencies.
+* 0.1.4 Changed json parser to yajl.
 * 0.1.3 Bug fix.
 * 0.1.2 Released gem.
 
+See commit logs about contributors.
+
 == Copyright
 
-Copyright:: Copyright (c) 2013 IZAWA Tetsu (@moccos)
+Copyright:: Copyright (c) 2013 Tetsu Izawa (@moccos)
 License:: Apache License, Version 2.0

data/examples/msgpack.js

@@ -0,0 +1,646 @@
+/* jshint browser: true */
+/* global define, module */
+( // Module boilerplate to support browser globals and browserify and AMD.
+  typeof define === "function" ? function (m) { define("msgpack-js", m); } :
+  typeof exports === "object" ? function (m) { module.exports = m(); } :
+  function(m){ this.msgpack = m(); }
+)(function () {
+"use strict";
+
+var exports = {};
+
+exports.inspect = inspect;
+function inspect(buffer) {
+  if (buffer === undefined) return "undefined";
+  var view;
+  var type;
+  if (buffer instanceof ArrayBuffer) {
+    type = "ArrayBuffer";
+    view = new DataView(buffer);
+  }
+  else if (buffer instanceof DataView) {
+    type = "DataView";
+    view = buffer;
+  }
+  if (!view) return JSON.stringify(buffer);
+  var bytes = [];
+  for (var i = 0; i < buffer.byteLength; i++) {
+    if (i > 20) {
+      bytes.push("...");
+      break;
+    }
+    var byte = view.getUint8(i).toString(16);
+    if (byte.length === 1) byte = "0" + byte;
+    bytes.push(byte);
+  }
+  return "<" + type + " " + bytes.join(" ") + ">";
+}
+
+// Encode string as utf8 into dataview at offset
+exports.utf8Write = utf8Write;
+function utf8Write(view, offset, string) {
+  var byteLength = view.byteLength;
+  for(var i = 0, l = string.length; i < l; i++) {
+    var codePoint = string.charCodeAt(i);
+
+    // One byte of UTF-8
+    if (codePoint < 0x80) {
+      view.setUint8(offset++, codePoint >>> 0 & 0x7f | 0x00);
+      continue;
+    }
+
+    // Two bytes of UTF-8
+    if (codePoint < 0x800) {
+      view.setUint8(offset++, codePoint >>> 6 & 0x1f | 0xc0);
+      view.setUint8(offset++, codePoint >>> 0 & 0x3f | 0x80);
+      continue;
+    }
+
+    // Three bytes of UTF-8.
+    if (codePoint < 0x10000) {
+      view.setUint8(offset++, codePoint >>> 12 & 0x0f | 0xe0);
+      view.setUint8(offset++, codePoint >>> 6  & 0x3f | 0x80);
+      view.setUint8(offset++, codePoint >>> 0  & 0x3f | 0x80);
+      continue;
+    }
+
+    // Four bytes of UTF-8
+    if (codePoint < 0x110000) {
+      view.setUint8(offset++, codePoint >>> 18 & 0x07 | 0xf0);
+      view.setUint8(offset++, codePoint >>> 12 & 0x3f | 0x80);
+      view.setUint8(offset++, codePoint >>> 6  & 0x3f | 0x80);
+      view.setUint8(offset++, codePoint >>> 0  & 0x3f | 0x80);
+      continue;
+    }
+    throw new Error("bad codepoint " + codePoint);
+  }
+}
+
+exports.utf8Read = utf8Read;
+function utf8Read(view, offset, length) {
+  var string = "";
+  for (var i = offset, end = offset + length; i < end; i++) {
+    var byte = view.getUint8(i);
+    // One byte character
+    if ((byte & 0x80) === 0x00) {
+      string += String.fromCharCode(byte);
+      continue;
+    }
+    // Two byte character
+    if ((byte & 0xe0) === 0xc0) {
+      string += String.fromCharCode(
+        ((byte & 0x1f) << 6) |
+        (view.getUint8(++i) & 0x3f)
+      );
+      continue;
+    }
+    // Three byte character
+    if ((byte & 0xf0) === 0xe0) {
+      string += String.fromCharCode(
+        ((byte & 0x0f) << 12) |
+        ((view.getUint8(++i) & 0x3f) << 6) |
+        ((view.getUint8(++i) & 0x3f) << 0)
+      );
+      continue;
+    }
+    // Four byte character
+    if ((byte & 0xf8) === 0xf0) {
+      string += String.fromCharCode(
+        ((byte & 0x07) << 18) |
+        ((view.getUint8(++i) & 0x3f) << 12) |
+        ((view.getUint8(++i) & 0x3f) << 6) |
+        ((view.getUint8(++i) & 0x3f) << 0)
+      );
+      continue;
+    }
+    throw new Error("Invalid byte " + byte.toString(16));
+  }
+  return string;
+}
+
+exports.utf8ByteCount = utf8ByteCount;
+function utf8ByteCount(string) {
+  var count = 0;
+  for(var i = 0, l = string.length; i < l; i++) {
+    var codePoint = string.charCodeAt(i);
+    if (codePoint < 0x80) {
+      count += 1;
+      continue;
+    }
+    if (codePoint < 0x800) {
+      count += 2;
+      continue;
+    }
+    if (codePoint < 0x10000) {
+      count += 3;
+      continue;
+    }
+    if (codePoint < 0x110000) {
+      count += 4;
+      continue;
+    }
+    throw new Error("bad codepoint " + codePoint);
+  }
+  return count;
+}
+
+exports.encode = function (value) {
+  var buffer = new ArrayBuffer(encodedSize(value));
+  var view = new DataView(buffer);
+  encode(value, view, 0);
+  return buffer;
+};
+
+exports.decode = decode;
+
+// https://github.com/msgpack/msgpack/blob/master/spec.md
+// we reserve extension type 0x00 to encode javascript 'undefined'
+
+function Decoder(view, offset) {
+  this.offset = offset || 0;
+  this.view = view;
+}
+Decoder.prototype.map = function (length) {
+  var value = {};
+  for (var i = 0; i < length; i++) {
+    var key = this.parse();
+    value[key] = this.parse();
+  }
+  return value;
+};
+Decoder.prototype.bin = function (length) {
+  var value = new ArrayBuffer(length);
+  (new Uint8Array(value)).set(new Uint8Array(this.view.buffer, this.offset, length), 0);
+  this.offset += length;
+  return value;
+};
+Decoder.prototype.str = function (length) {
+  var value = utf8Read(this.view, this.offset, length);
+  this.offset += length;
+  return value;
+};
+Decoder.prototype.array = function (length) {
+  var value = new Array(length);
+  for (var i = 0; i < length; i++) {
+    value[i] = this.parse();
+  }
+  return value;
+};
+Decoder.prototype.parse = function () {
+  var type = this.view.getUint8(this.offset);
+  var value, length;
+  // FixStr
+  if ((type & 0xe0) === 0xa0) {
+    length = type & 0x1f;
+    this.offset++;
+    return this.str(length);
+  }
+  // FixMap
+  if ((type & 0xf0) === 0x80) {
+    length = type & 0x0f;
+    this.offset++;
+    return this.map(length);
+  }
+  // FixArray
+  if ((type & 0xf0) === 0x90) {
+    length = type & 0x0f;
+    this.offset++;
+    return this.array(length);
+  }
+  // Positive FixNum
+  if ((type & 0x80) === 0x00) {
+    this.offset++;
+    return type;
+  }
+  // Negative Fixnum
+  if ((type & 0xe0) === 0xe0) {
+    value = this.view.getInt8(this.offset);
+    this.offset++;
+    return value;
+  }
+  // Undefined as FixExt1
+  if (type === 0xd4 && this.view.getUint8(this.offset + 1) === 0x00) {
+    this.offset += 3;
+    return undefined;
+  }
+  switch (type) {
+  // str 8
+  case 0xd9:
+    length = this.view.getUint8(this.offset + 1);
+    this.offset += 2;
+    return this.str(length);
+  // str 16
+  case 0xda:
+    length = this.view.getUint16(this.offset + 1);
+    this.offset += 3;
+    return this.str(length);
+  // str 32
+  case 0xdb:
+    length = this.view.getUint32(this.offset + 1);
+    this.offset += 5;
+    return this.str(length);
+  // bin 8
+  case 0xc4:
+    length = this.view.getUint8(this.offset + 1);
+    this.offset += 2;
+    return this.bin(length);
+  // bin 16
+  case 0xc5:
+    length = this.view.getUint16(this.offset + 1);
+    this.offset += 3;
+    return this.bin(length);
+  // bin 32
+  case 0xc6:
+    length = this.view.getUint32(this.offset + 1);
+    this.offset += 5;
+    return this.bin(length);
+  // nil
+  case 0xc0:
+    this.offset++;
+    return null;
+  // false
+  case 0xc2:
+    this.offset++;
+    return false;
+  // true
+  case 0xc3:
+    this.offset++;
+    return true;
+  // uint8
+  case 0xcc:
+    value = this.view.getUint8(this.offset + 1);
+    this.offset += 2;
+    return value;
+  // uint 16
+  case 0xcd:
+    value = this.view.getUint16(this.offset + 1);
+    this.offset += 3;
+    return value;
+  // uint 32
+  case 0xce:
+    value = this.view.getUint32(this.offset + 1);
+    this.offset += 5;
+    return value;
+  // uint 64
+  case 0xcf:
+    var high = this.view.getUint32(this.offset + 1);
+    var low = this.view.getUint32(this.offset + 5);
+    value = high*0x100000000 + low;
+    this.offset += 9;
+    return value;
+  // int 8
+  case 0xd0:
+    value = this.view.getInt8(this.offset + 1);
+    this.offset += 2;
+    return value;
+  // int 16
+  case 0xd1:
+    value = this.view.getInt16(this.offset + 1);
+    this.offset += 3;
+    return value;
+  // int 32
+  case 0xd2:
+    value = this.view.getInt32(this.offset + 1);
+    this.offset += 5;
+    return value;
+  // int 64
+  case 0xd3:
+    var high = this.view.getInt32(this.offset + 1);
+    var low = this.view.getUint32(this.offset + 5);
+    value = high*0x100000000 + low;
+    this.offset += 9;
+    return value;
+  // map 16
+  case 0xde:
+    length = this.view.getUint16(this.offset + 1);
+    this.offset += 3;
+    return this.map(length);
+  // map 32
+  case 0xdf:
+    length = this.view.getUint32(this.offset + 1);
+    this.offset += 5;
+    return this.map(length);
+  // array 16
+  case 0xdc:
+    length = this.view.getUint16(this.offset + 1);
+    this.offset += 3;
+    return this.array(length);
+  // array 32
+  case 0xdd:
+    length = this.view.getUint32(this.offset + 1);
+    this.offset += 5;
+    return this.array(length);
+  // float
+  case 0xca:
+    value = this.view.getFloat32(this.offset + 1);
+    this.offset += 5;
+    return value;
+  // double
+  case 0xcb:
+    value = this.view.getFloat64(this.offset + 1);
+    this.offset += 9;
+    return value;
+  }
+  throw new Error("Unknown type 0x" + type.toString(16));
+};
+function decode(buffer) {
+  var view = new DataView(buffer);
+  var decoder = new Decoder(view);
+  var value = decoder.parse();
+  if (decoder.offset !== buffer.byteLength) throw new Error((buffer.byteLength - decoder.offset) + " trailing bytes");
+  return value;
+}
+
+function encode(value, view, offset) {
+  var type = typeof value;
+
+  // Strings Bytes
+  if (type === "string") {
+    var length = utf8ByteCount(value);
+    // fix str
+    if (length < 0x20) {
+      view.setUint8(offset, length | 0xa0);
+      utf8Write(view, offset + 1, value);
+      return 1 + length;
+    }
+    // str 8
+    if (length < 0x100) {
+      view.setUint8(offset, 0xd9);
+      view.setUint8(offset + 1, length);
+      utf8Write(view, offset + 2, value);
+      return 2 + length;
+    }
+    // str 16
+    if (length < 0x10000) {
+      view.setUint8(offset, 0xda);
+      view.setUint16(offset + 1, length);
+      utf8Write(view, offset + 3, value);
+      return 3 + length;
+    }
+    // str 32
+    if (length < 0x100000000) {
+      view.setUint8(offset, 0xdb);
+      view.setUint32(offset + 1, length);
+      utf8Write(view, offset + 5, value);
+      return 5 + length;
+    }
+  }
+
+  if (value instanceof ArrayBuffer) {
+    var length = value.byteLength;
+    // bin 8
+    if (length < 0x100) {
+      view.setUint8(offset, 0xc4);
+      view.setUint8(offset + 1, length);
+      (new Uint8Array(view.buffer)).set(new Uint8Array(value), offset + 2);
+      return 2 + length;
+    }
+    // bin 16
+    if (length < 0x10000) {
+      view.setUint8(offset, 0xc5);
+      view.setUint16(offset + 1, length);
+      (new Uint8Array(view.buffer)).set(new Uint8Array(value), offset + 3);
+      return 3 + length;
+    }
+    // bin 32
+    if (length < 0x100000000) {
+      view.setUint8(offset, 0xc6);
+      view.setUint32(offset + 1, length);
+      (new Uint8Array(view.buffer)).set(new Uint8Array(value), offset + 5);
+      return 5 + length;
+    }
+  }
+
+  if (type === "number") {
+    // Floating Point
+    if ((value << 0) !== value) {
+      view.setUint8(offset, 0xcb);
+      view.setFloat64(offset + 1, value);
+      return 9;
+    }
+
+    // Integers
+    if (value >=0) {
+      // positive fixnum
+      if (value < 0x80) {
+        view.setUint8(offset, value);
+        return 1;
+      }
+      // uint 8
+      if (value < 0x100) {
+        view.setUint8(offset, 0xcc);
+        view.setUint8(offset + 1, value);
+        return 2;
+      }
+      // uint 16
+      if (value < 0x10000) {
+        view.setUint8(offset, 0xcd);
+        view.setUint16(offset + 1, value);
+        return 3;
+      }
+      // uint 32
+      if (value < 0x100000000) {
+        view.setUint8(offset, 0xce);
+        view.setUint32(offset + 1, value);
+        return 5;
+      }
+      throw new Error("Number too big 0x" + value.toString(16));
+    }
+    // negative fixnum
+    if (value >= -0x20) {
+      view.setInt8(offset, value);
+      return 1;
+    }
+    // int 8
+    if (value >= -0x80) {
+      view.setUint8(offset, 0xd0);
+      view.setInt8(offset + 1, value);
+      return 2;
+    }
+    // int 16
+    if (value >= -0x8000) {
+      view.setUint8(offset, 0xd1);
+      view.setInt16(offset + 1, value);
+      return 3;
+    }
+    // int 32
+    if (value >= -0x80000000) {
+      view.setUint8(offset, 0xd2);
+      view.setInt32(offset + 1, value);
+      return 5;
+    }
+    throw new Error("Number too small -0x" + (-value).toString(16).substr(1));
+  }
+
+  // undefined
+  if (type === "undefined") {
+    view.setUint8(offset, 0xd4);  // fixext 1
+    view.setUint8(offset + 1, 0); // type (undefined)
+    view.setUint8(offset + 2, 0); // data (ignored)
+    return 3;
+  }
+
+  // null
+  if (value === null) {
+    view.setUint8(offset, 0xc0);
+    return 1;
+  }
+
+  // Boolean
+  if (type === "boolean") {
+    view.setUint8(offset, value ? 0xc3 : 0xc2);
+    return 1;
+  }
+
+  // Container Types
+  if (type === "object") {
+    var length, size = 0;
+    var isArray = Array.isArray(value);
+
+    if (isArray) {
+      length = value.length;
+    }
+    else {
+      var keys = Object.keys(value);
+      length = keys.length;
+    }
+
+    var size;
+    if (length < 0x10) {
+      view.setUint8(offset, length | (isArray ? 0x90 : 0x80));
+      size = 1;
+    }
+    else if (length < 0x10000) {
+      view.setUint8(offset, isArray ? 0xdc : 0xde);
+      view.setUint16(offset + 1, length);
+      size = 3;
+    }
+    else if (length < 0x100000000) {
+      view.setUint8(offset, isArray ? 0xdd : 0xdf);
+      view.setUint32(offset + 1, length);
+      size = 5;
+    }
+
+    if (isArray) {
+      for (var i = 0; i < length; i++) {
+        size += encode(value[i], view, offset + size);
+      }
+    }
+    else {
+      for (var i = 0; i < length; i++) {
+        var key = keys[i];
+        size += encode(key, view, offset + size);
+        size += encode(value[key], view, offset + size);
+      }
+    }
+
+    return size;
+  }
+  throw new Error("Unknown type " + type);
+}
+
+function encodedSize(value) {
+  var type = typeof value;
+
+  // Raw Bytes
+  if (type === "string") {
+    var length = utf8ByteCount(value);
+    if (length < 0x20) {
+      return 1 + length;
+    }
+    if (length < 0x100) {
+      return 2 + length;
+    }
+    if (length < 0x10000) {
+      return 3 + length;
+    }
+    if (length < 0x100000000) {
+      return 5 + length;
+    }
+  }
+
+  if (value instanceof ArrayBuffer) {
+    var length = value.byteLength;
+    if (length < 0x100) {
+      return 2 + length;
+    }
+    if (length < 0x10000) {
+      return 3 + length;
+    }
+    if (length < 0x100000000) {
+      return 5 + length;
+    }
+  }
+
+  if (type === "number") {
+    // Floating Point
+    // double
+    if (value << 0 !== value) return 9;
+
+    // Integers
+    if (value >=0) {
+      // positive fixnum
+      if (value < 0x80) return 1;
+      // uint 8
+      if (value < 0x100) return 2;
+      // uint 16
+      if (value < 0x10000) return 3;
+      // uint 32
+      if (value < 0x100000000) return 5;
+      // uint 64
+      if (value < 0x10000000000000000) return 9;
+      throw new Error("Number too big 0x" + value.toString(16));
+    }
+    // negative fixnum
+    if (value >= -0x20) return 1;
+    // int 8
+    if (value >= -0x80) return 2;
+    // int 16
+    if (value >= -0x8000) return 3;
+    // int 32
+    if (value >= -0x80000000) return 5;
+    // int 64
+    if (value >= -0x8000000000000000) return 9;
+    throw new Error("Number too small -0x" + value.toString(16).substr(1));
+  }
+
+  // undefined
+  if (type === "undefined") return 3;
+
+  // Boolean, null
+  if (type === "boolean" || value === null) return 1;
+
+  // Container Types
+  if (type === "object") {
+    var length, size = 0;
+    if (Array.isArray(value)) {
+      length = value.length;
+      for (var i = 0; i < length; i++) {
+        size += encodedSize(value[i]);
+      }
+    }
+    else {
+      var keys = Object.keys(value);
+      length = keys.length;
+      for (var i = 0; i < length; i++) {
+        var key = keys[i];
+        size += encodedSize(key) + encodedSize(value[key]);
+      }
+    }
+    if (length < 0x10) {
+      return 1 + size;
+    }
+    if (length < 0x10000) {
+      return 3 + size;
+    }
+    if (length < 0x100000000) {
+      return 5 + size;
+    }
+    throw new Error("Array or object too long 0x" + length.toString(16));
+  }
+  throw new Error("Unknown type " + type);
+}
+
+return exports;
+
+});

data/examples/websocket.html

@@ -0,0 +1,81 @@
+<!DOCTYPE html>
+</head>
+  <meta charset="utf-8" />
+  <title>WebSocket Test</title>
+</head>
+<!-- based on http://www.websocket.org/echo.html -->
+<body>
+<!-- https://github.com/creationix/msgpack-js-browser --><script src="./msgpack.js"></script>
+<script language="javascript" type="text/javascript">
+
+  var wsUri = "ws://localhost:38080/";
+  var output;
+  var latestData;  // for debugging
+
+  function init()
+  {
+    output = document.getElementById("output");
+    testWebSocket();
+  }
+
+  function testWebSocket()
+  {
+    websocket = new WebSocket(wsUri);
+    websocket.binaryType = "arraybuffer";
+    websocket.onopen = function(evt) { onOpen(evt) };
+    websocket.onclose = function(evt) { onClose(evt) };
+    websocket.onmessage = function(evt) { onMessage(evt) };
+    websocket.onerror = function(evt) { onError(evt) };
+  }
+
+  function onOpen(evt)
+  {
+    writeToScreen("CONNECTED");
+    doSend("onOpen");
+  }
+
+  function onClose(evt)
+  {
+    writeToScreen("DISCONNECTED");
+  }
+
+  function onMessage(evt)
+  {
+    latestData = evt.data
+    if (typeof(evt.data) == 'string') {
+      text = evt.data;
+    } else {
+      decoded = msgpack.decode(evt.data);
+      text = JSON.stringify(decoded.slice(1));
+    }
+    writeToScreen('<span style="color: blue;">RESPONSE: ' + text +'</span>');
+  }
+
+  function onError(evt)
+  {
+    writeToScreen('<span style="color: red;">ERROR:</span> ' + evt.data);
+  }
+
+  function doSend(message)
+  {
+    writeToScreen("SENT: " + message);
+    websocket.send(message);
+  }
+
+  function writeToScreen(message)
+  {
+    var pre = document.createElement("p");
+    pre.style.wordWrap = "break-word";
+    pre.innerHTML = message;
+    output.appendChild(pre);
+  }
+
+  window.addEventListener("load", init, false);
+
+  </script>
+
+  <h2>WebSocket Test</h2>
+
+  <div id="output"></div>
+</body>
+

data/fluent-plugin-websocket.gemspec

@@ -3,8 +3,8 @@ $:.push File.expand_path('../lib', __FILE__)
 
 Gem::Specification.new do |gem|
   gem.name          = "fluent-plugin-websocket"
-  gem.version       = "0.1.7"
-  gem.authors       = ["IZAWA Tetsu (@moccos)"]
+  gem.version       = "0.1.8"
+  gem.authors       = ["Tetsu Izawa (@moccos)"]
   gem.email         = ["tt.izawa@gmail.com"]
   gem.homepage      = "https://github.com/moccos/fluent-plugin-websocket"
   gem.summary       = %q{Fluentd websocket output plugin}

data/lib/fluent/plugin/out_websocket.rb

@@ -28,6 +28,7 @@ module Fluent
     config_param :add_time, :bool, :default => false
     config_param :add_tag, :bool, :default => true
     config_param :buffered_messages, :integer, :default => 0
+    config_param :token, :string, :default => nil
 
     def configure(conf)
       super
@@ -37,19 +38,28 @@ module Fluent
         EM.run {
           EM::WebSocket.run(:host => @host, :port => @port) do |ws|
             ws.onopen { |handshake|
-              callback = @use_msgpack ? proc{|msg| ws.send_binary(msg)} : proc{|msg| ws.send(msg)}
-              $lock.synchronize do
-                sid = $channel.subscribe callback
-                $log.trace "WebSocket connection: ID " + sid.to_s
-                ws.onclose {
-                  $log.trace "Connection closed: ID " + sid.to_s
-                  $lock.synchronize do
-                    $channel.unsubscribe(sid)
+              $log.info "WebSocket opened #{{
+                :path => handshake.path,
+                :query => handshake.query,
+                :origin => handshake.origin,
+              }}"
+              if doAuth(handshake.query)
+                callback = @use_msgpack ? proc{|msg| ws.send_binary(msg)} : proc{|msg| sendMsg(handshake.query, ws, msg)}
+                $lock.synchronize do
+                  sid = $channel.subscribe callback
+                  $log.trace "WebSocket connection: ID " + sid.to_s
+                  ws.onclose {
+                    $log.trace "Connection closed: ID " + sid.to_s
+                    $lock.synchronize do
+                      $channel.unsubscribe(sid)
+                    end
+                  }
+                  @buffer.each do |msg|
+                    sendMsg(handshake.query, ws, msg)
                   end
-                }
-                @buffer.each do |msg|
-                  ws.send(msg)
                 end
+              else
+                ws.send("Unauthorized")
               end
 
               #ws.onmessage { |msg|
@@ -60,6 +70,31 @@ module Fluent
       end
     end
 
+    def doAuth(query)
+      if @token.nil? || ( query.key?("token") && @token == query["token"] )
+        $log.trace "Auth OK"
+        return true
+      end
+
+      $log.trace "Auth failed"
+      return false
+    end
+
+    def sendMsg(filters, ws, msg)
+      parser = Yajl::Parser.new
+      msgStruct = parser.parse(msg)
+      return if msgStruct.length != 2
+      msgContent = msgStruct[1]
+
+      pass = 0
+
+      filters.each do |key, value|
+        pass += 1 if key == 'token' || ( msgContent.key?(key) && msgContent[key] == value )
+      end
+
+      ws.send(msg) if filters.length == pass
+    end
+
     def start
       @buffer = []
       super

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fluent-plugin-websocket
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
-- IZAWA Tetsu (@moccos)
+- Tetsu Izawa (@moccos)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-04 00:00:00.000000000 Z
+date: 2018-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -107,6 +107,8 @@ files:
 - LICENSE.txt
 - README.rdoc
 - Rakefile
+- examples/msgpack.js
+- examples/websocket.html
 - fluent-plugin-websocket.gemspec
 - lib/fluent/plugin/out_websocket.rb
 - test/plugin/test_out_websocket.rb
@@ -130,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Fluentd websocket output plugin