whatap 1.0.1-canary.2 → 1.0.2

package/lib/net/tcp-session.js

@@ -0,0 +1,286 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var net             = require('net'),
+    netflag         = require('./netflag').NetFlag,
+    netsrc          = require('./netflag').NetSrc,
+    secu            = require('./security-master'),
+    conf            = require('./../conf/configure'),
+    DataOutputX     = require('./../io/data-outputx'),
+    DataInputX      = require('./../io/data-inputx'),
+    IPUtil          = require('./../util/iputil'),
+    TcpReturn       = require('./tcp-return'),
+    Receiver        = require('./receiver'),
+    OidUtil         = require('../util/oidutil'),
+    Logger          = require('../logger'),
+    Long            = require('long');
+
+function TcpSession() {
+    if(typeof TcpSession.instance === 'object') {
+        return TcpSession.instance;
+    }
+
+    this.in = null;
+    this.out = null;
+    this.receiver = new Receiver();
+    this._cb = null;
+    this.reconnectCnt = 0;
+    TcpSession.instance = this;
+}
+
+TcpSession.prototype.open = function(cb){
+    var self = this;
+    
+    if(cb) this._cb = cb;
+
+    self.auto_oname_reset = conf.auto_oname_reset;
+    if(secu.PCODE == null || secu.PCODE === 0) {
+        if(cb) return cb(new Error('PCODE is not defined..'));
+    }
+    if(this.isOpen()) { 
+        ++self.reconnectCnt;
+        if(self.reconnectCnt >= 3) {
+            self.close();
+        }
+        return cb(new Error('Already connected..')); 
+    }
+
+    var host = conf.getWhatapServerHost();
+    var port = conf.whatap_server_port || 6600;
+    var connection_timeout = conf.tcp_connection_timeout;
+
+    var options = {
+        host: host,
+        port: port
+    };
+
+    Logger.print('WHATAP-180', "Try to connect to " + JSON.stringify(options), false);
+    this.out = net.connect(options, function() {
+        var localAddr = (this.localAddress || IPUtil.getIp());
+        
+        if(conf.auto_oname_enabled === true) {
+            var oname = conf["whatap.oname"];
+            if((oname == null || oname.length === 0)
+                && self.auto_oname_reset === conf.auto_oname_reset) {
+                self.prepareAutoOnameByServer(localAddr);
+                return;
+            }
+        }
+        
+        secu.decideAgentOnameOid(localAddr);
+        if(conf.cipher_net_enabled){
+            try {
+                self.out.write( self.keyReset() );
+            } catch(e) {
+                Logger.printError("WHATAP-125", "KeyReset " + host + ":" + port, e, true);
+            }
+        }
+    });
+
+    this.out.setKeepAlive(true , 60000);
+    this.out.setTimeout(connection_timeout);
+
+    this.out.on('error', function (err) {
+        Logger.printError("WHATAP-127", 'Failed to connect to ' + JSON.stringify(options), err);
+        self.close();
+        cb(err);
+    });
+
+    this.out.on('timeout' , function () {
+        Logger.print("WHATAP-184", "Socket timeout. WhaTap will retry connect after " + (connection_timeout/1000) + " sec.", false);
+        self.close();
+        setTimeout(function() {
+            self.open(cb);
+        } , 500);
+    });
+
+    var firstReceived = false;
+    this.out.on('data', function(data) {
+        if(self.PREPARE_AGENT) {
+            var din = new DataInputX(data);
+            var source = din.readByte();
+            var code = din.readByte();
+            var pcode = din.readLong();
+            var oid = din.readInt();
+            var transfer_key = din.readInt();
+            var _data = din.readIntBytes(8 * 1024 * 1024);
+            if (conf.cypher_level > 0) {
+                _data = secu.cypher.decrypt(_data);
+            }
+
+            var oname = new DataInputX(_data).readText();
+            
+            var localAddr = (this.localAddress || IPUtil.getIp());
+            secu.setAgentOnameOid(oname, localAddr);
+            self.PREPARE_AGENT = false;
+            if(conf.cipher_net_enabled) {
+                try {
+                    self.out.write( self.keyReset() );
+                } catch(e) {
+                    Logger.printError("WHATAP-125", "KeyReset " + host + ":" + port, e, true);
+                }
+            }
+            return;
+        }
+        
+        if(firstReceived) {
+            self.read(data);
+            return;
+        }
+        var d = self.readKeyReset(data);
+        if( d && d.length != 0 ) {
+            conf.updateNetCypherKey(d);
+            firstReceived = true;
+            if(cb) cb();
+        }
+    });
+
+    this.out.on('end', function(){
+        Logger.print("WHATAP-183", "Disconnected from server, please check your network or Whatap Server!!!!!", false);
+        self.close();
+        setTimeout(function() {
+            cb(new Error('Socket end Event!!!!!'));
+            return;
+        },500);
+    });
+};
+
+TcpSession.prototype.close = function(){
+    if(this.out){ 
+        this.out.destroy();
+        this.out = null;
+        this.reconnectCnt = 0;
+    }
+}
+
+TcpSession.prototype.send = function(code , b ){
+    try{
+        if(this.out == null ){
+            return false;
+        }
+        var out = new DataOutputX();
+        out.writeByte(netsrc.AGENT_JAVA_EMBED);
+        out.writeByte(code);
+        out.writeLong(secu.PCODE);
+        out.writeInt(secu.OID);
+        out.writeInt(conf.TRANSFER_KEY);
+        out.writeIntBytes(b);
+        /*if(this.out === null ){
+            if(this._cb) {
+                setTimeout(function() {
+                    this._cb(new Error('[Send Error] Socket is null !! TCP Session Reconnection......'));
+                    return;
+                },100);
+         }
+          } */
+        this.out.write(out.toByteArray());
+        return true;
+    } catch(e) {
+        Logger.printError('WHATAP-126', 'TcpSession Error', e);
+    }
+    this.close();
+    return false;
+};
+TcpSession.prototype.readKeyReset = function( inPS /* DataInputX */){
+    try {
+        if( inPS.constructor === Buffer){
+            inPS = new DataInputX(inPS);
+        }
+        var source = inPS.readByte();
+        var code = inPS.readByte();
+        var pcode = inPS.readLong();
+        var oid = inPS.readInt();
+        var transfer_key = inPS.readInt();
+        var data = inPS.readIntBytes(1024);
+
+        if( pcode != secu.PCODE || oid != secu.OID){
+            return null;
+        } else {
+            return data;
+        }
+    } catch(e) {
+        Logger.printError("WHATAP-189", 'License key or invalid agent version error(fail key)', e, true);
+    }
+};
+
+TcpSession.prototype.keyReset = function(){
+    var msg = new DataOutputX().writeText("hello").writeText(secu.ONAME).writeInt8(secu.IP).toByteArray();
+    if( conf.cypher_level > 0 ){
+        msg = secu.cypher.encrypt(msg);
+    }
+
+    var out = new DataOutputX();
+    out.writeByte(netsrc.AGENT_JAVA_EMBED);
+    out.writeByte(netflag.KEY_RESET);
+    out.writeLong(Long.fromValue(secu.PCODE));
+    out.writeInt(secu.OID);
+    out.writeInt(0);
+    out.writeIntBytes(msg);
+    return out.toByteArray();
+};
+
+TcpSession.prototype.isOpen = function(){
+    return this.out != null;
+};
+
+TcpSession.prototype.read = function (data) {
+    var din = new DataInputX(data);
+    var out = new TcpReturn();
+    var source = din.readByte();
+
+    out.code = din.readByte();
+    var pcode = din.readLong();
+    var oid = din.readInt();
+    out.transfer_key = din.readInt();
+    out.data = din.readIntBytes();
+
+    if(pcode != secu.PCODE || oid != secu.OID) {
+        Logger.printError('WHATAP-190', 'Received data is not mine..', new Error('Receive data error'));
+        return null;
+    }
+    this.receiver.read(out);
+};
+TcpSession.prototype.prepareAutoOnameByServer = function (localAddr) {
+    var self = this;
+    try {
+        var auto_oname_prefix = conf.auto_oname_prefix;
+
+        if(auto_oname_prefix.indexOf('{') >= 0) {
+            OidUtil.setIp(localAddr);
+            OidUtil.setPort(port);
+            OidUtil.setPid(process.pid);
+            OidUtil.setHostName(require('os').hostname());
+            auto_oname_prefix = OidUtil.mkOname(conf.auto_oname_prefix);
+        }
+
+        var pout = new DataOutputX();
+        pout.writeText(auto_oname_prefix);
+        pout.writeInt(IPUtil.stringToInt(localAddr));
+        var msg = pout.toByteArray();
+
+        var trkey = 0;
+        if(conf.cypher_level > 0) {
+            msg = secu.cypher.encrypt(msg);
+            var b0 = 1;
+            var b1 = (conf.cypher_level / 8);
+            trkey = DataInputX.toInt([b0, b1, 0, 0], 0);
+        }
+
+        var out = new DataOutputX();
+        out.writeByte(netsrc.AGENT_JAVA_EMBED);
+        out.writeByte(netflag.PREPARE_AGENT);
+        out.writeLong(secu.PCODE);
+        out.writeInt(0);
+        out.writeInt(trkey);
+        out.writeIntBytes(msg);
+        self.PREPARE_AGENT = true;
+        self.out.write(out.toByteArray());
+    } catch(e) {
+        Logger.printError("WHATAP-003", "Prepare oname error", e, false);
+    }
+};
+
+module.exports = new TcpSession();

package/lib/net/tcpreq-client-proxy.js

@@ -0,0 +1,70 @@
+var net             = require('net'),
+    DataOutputX     = require('../io/data-outputx'),
+    DataInputX      = require('../io/data-inputx'),
+    Logger          = require('../logger')
+;
+var READ_MAX = 8 * 1024 * 1024;
+
+var TcpRequestClientProxy = function(msg){
+    this.msg = msg;
+    this.failConLog = true;
+}
+
+TcpRequestClientProxy.prototype.close = function(){
+    if(!this.client) return;
+
+    this.client.destroy();
+    this.client = undefined;
+}
+
+TcpRequestClientProxy.prototype.isOpen = function(){
+
+}
+
+TcpRequestClientProxy.prototype.send = function(din){
+    if(!this.client) return;
+
+    var out = new DataOutputX();
+    out.write(ss(0XCAFE));
+    out.writeIntBytes(din.toByteArray())
+
+    this.client.write( out.toByteArray()
+        , function(error, data){
+            if(error){
+                return Logger.printError('WHATAP-996', 'TcpRequestClientProxy (send)', e, true);
+            }
+        }
+    );
+}
+
+TcpRequestClientProxy.prototype.open = function(host, port, connectCb, dataCb){
+    var self = this;
+
+    this.client = net.connect({host: host, port: port}, connectCb);
+    this.client.on('data', function(data) {
+        var din = new DataInputX(data);
+        var cafe = din.readUInt16BE();
+        var bytes = din.readIntBytes(READ_MAX);
+
+        if(dataCb) dataCb(undefined, bytes);
+        self.close();
+    });
+
+    this.client.on('error', function (err) {
+        Logger.printError("WHATAP-128", 'Failed to connect to ' + self.msg , err, true);        
+        if(dataCb) dataCb(err);
+    });
+
+    this.client.on('close', function() {
+        self.close();
+    });
+}
+
+function ss(v) {
+    var buf = new Array(2);
+    buf[0] = ((v >>> 8) & 0xFF);
+    buf[1] = ((v >>> 0) & 0xFF);
+    return buf;
+};
+
+module.exports = TcpRequestClientProxy;

package/lib/net/tcprequest-mgr.js

@@ -0,0 +1,58 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var Sender      = require('./sender'),
+    Receiver    = require('./receiver'),
+    conf        = require('./../conf/configure'),
+    Logger      = require('../logger'),
+    RequestDoubleQueue = require('./../util/requestdouble-queue');
+
+var TcpRequestManager = function(agent){
+    if(TcpRequestManager.instance === 'object') {
+        return TcpRequestManager.instance;
+    }
+
+    this.agent = agent;
+    this.sender1 = new Sender(agent, this);
+    this.sender2 = new Sender(agent, this);
+    this.receiver = new Receiver(agent, this);
+    this.pool = new RequestDoubleQueue(conf.net_send_queue1_size, conf.net_send_queue2_size);
+    this.sendDropped = 0;
+    this.isExistData = false;
+
+    TcpRequestManager.instance = this;
+};
+TcpRequestManager.prototype.add = function(flag, p){
+    var _this = this;
+    var ok = this.pool.put1({flag: flag, pack: p});
+    if(ok === false){
+        this.sendDropped++;
+        Logger.print("WHATAP-201", 'Data[1] drop count : ' + this.sendDropped)
+    } else {
+        process.nextTick(function () {
+            _this.notify();
+        });
+    }
+};
+TcpRequestManager.prototype.addProfile = function(flag, p) {
+    var self = this;
+    var ok = this.pool.put2({flag: flag, pack: p});
+
+    if(ok === false){
+        this.sendDropped++;
+        Logger.print("WHATAP-201", 'Data[2] drop count : ' + this.sendDropped)
+    }else{
+        process.nextTick(function () {
+            self.notify();
+        });
+    }
+};
+TcpRequestManager.prototype.notify = function(){
+    this.sender1.startCheckQueue();
+    this.sender2.startCheckQueue();
+};
+
+module.exports = new TcpRequestManager();

package/lib/observers/apollo-server-observer.js

@@ -8,9 +8,11 @@ var TraceContextManager = require('../trace/trace-context-manager'),
     conf = require('../conf/configure'),
     Logger = require('../logger');
 const HashUtil = require('../util/hashutil');
+const DataTextAgent = require('../data/datatext-agent');
+const MessageStep = require('../step/message-step');
 const shimmer = require('../core/shimmer');
-const AsyncSender = require('../udp/async_sender');
-const PacketTypeEnum = require('../udp/packet_type_enum');
+const StatError = require("whatap/lib/stat/stat-error");
+const TextTypes = require("whatap/lib/lang/text-types");
 
 var profile_graphql_enabled = conf.getProperty('profile_graphql_enabled', true);
 var profile_graphql_variable_enabled = conf.getProperty('profile_graphql_variable_enabled', false);
@@ -43,7 +45,7 @@ function checkIgnoreOperation(ignore_operation, operation_name) {
             return true;
         }
     } catch (e) {
-        Logger.printError('WHATAP-248', 'GraphQL checkIgnoreOperation error: ' + e, false);
+        Logger.printError('WHATAP-803', 'GraphQL checkIgnoreOperation error: ' + e, false);
     }
     return false;
 }
@@ -78,25 +80,32 @@ function wrapExecuteHTTPGraphQLRequest(original) {
 
             // Operation Type Step (query)
             if(body.query && body.query.trim()){
-                const queryType = body.query.trim().startsWith('mutation') ? 'mutation' : 'query';
-                let typeDatas = ['Type', 'Type', queryType];
-                ctx.start_time = Date.now();
-                AsyncSender.send_packet(PacketTypeEnum.TX_MSG, ctx, typeDatas);
+                var step_type = new MessageStep();
+                step_type.hash = HashUtil.hashFromString('Type');
+                step_type.start_time = ctx.getElapsedTime();
+                step_type.desc = body.query.trim().startsWith('mutation') ? 'mutation' : 'query';
+                DataTextAgent.MESSAGE.add(step_type.hash, "Type");
+                ctx.profile.push(step_type);
             }
 
             // Operation Name Step
             if(operationName){
-                let operationDatas = ['Operation', 'Operation', operationName || 'anonymous'];
-                ctx.start_time = Date.now();
-                AsyncSender.send_packet(PacketTypeEnum.TX_MSG, ctx, operationDatas);
+                var step_operation = new MessageStep();
+                step_operation.hash = HashUtil.hashFromString('Operation');
+                step_operation.start_time = ctx.getElapsedTime();
+                step_operation.desc = operationName || 'anonymous';
+                DataTextAgent.MESSAGE.add(step_operation.hash, "Operation");
+                ctx.profile.push(step_operation);
             }
 
             // Variables Step
             if (profile_graphql_variable_enabled && body.variables && Object.keys(body.variables).length > 0) {
-                const variableKeys = JSON.stringify(Object.keys(body.variables));
-                let variableDatas = ['Variables', 'Variables', variableKeys];
-                ctx.start_time = Date.now();
-                AsyncSender.send_packet(PacketTypeEnum.TX_MSG, ctx, variableDatas);
+                var step_variables = new MessageStep();
+                step_variables.hash = HashUtil.hashFromString('Variables');
+                step_variables.start_time = ctx.getElapsedTime();
+                step_variables.desc = JSON.stringify(Object.keys(body.variables));
+                DataTextAgent.MESSAGE.add(step_variables.hash, "Variables");
+                ctx.profile.push(step_variables);
             }
 
             const response = await original.apply(this, arguments);
@@ -107,30 +116,27 @@ function wrapExecuteHTTPGraphQLRequest(original) {
                     const result = JSON.parse(response.body.string);
                     if (result.errors && result.errors.length > 0) {
                         const errorMessages = result.errors.map(error => error.message).join('\n');
-                        ctx.status = response.status;
+                        ctx.statusCode = response.status;
+                        ctx.error_message = errorMessages;
+                        ctx.error_class = 'GraphQLError';
 
-                        if (response.status >= 400 && !ctx.error) {
-                            ctx.error = 1;
-                            let errors = ['GraphQLError', errorMessages];
-                            AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
+                        if(ctx.error.isZero()){
+                            ctx.error = StatError.addError(response.status, errorMessages, ctx.service_hash, TextTypes.SQL, HashUtil.hashFromString(ctx.service_name));
                         }
                     }
                 } catch (e) {
-                    Logger.printError('WHATAP-249', 'GraphQL error parsing failed', e, false);
+                    Logger.printError('WHATAP-802', 'GraphQL error parsing failed', e, false);
                 }
             }
 
             return response;
 
         } catch (err) {
-            Logger.printError('WHATAP-250', 'GraphQL executeHTTPGraphQLRequest error: ' + err, false);
+            Logger.printError('WHATAP-801', 'GraphQL executeHTTPGraphQLRequest error: ' + err, false);
             if (ctx) {
-                ctx.status = 500;
-                if (!ctx.error) {
-                    ctx.error = 1;
-                    let errors = [err.name || err.constructor?.name || 'UnknownError', err.message];
-                    AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
-                }
+                ctx.statusCode = 500;
+                ctx.error_message = err.message;
+                ctx.error_class = err.name || err.constructor?.name || 'UnknownError'
             }
             return original.apply(this, arguments);
         }

package/lib/observers/cluster-observer.js

@@ -0,0 +1,22 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var ClusterObserver = function(agent){
+    this.agent = agent;
+    this.packages = ['cluster'];
+}
+
+ClusterObserver.prototype.inject = function( mod ){
+    var aop = this.agent.aop;
+
+    aop.before(mod, 'fork', function(obj, args, result){
+    });
+
+    aop.after(mod, 'fork', function(obj, args, result){
+    });
+};
+
+exports.ClusterObserver = ClusterObserver;