Node.js runtime

Currently, Function Compute supports the Node.js 6.10 (runtime version 6) and Node.js 8.9.0 (runtime version 8).

Contents

This topic describes the following features of Node.js runtime environments:

• Use the logging module
• Use built-in modules
• Use custom modules
• Use external commands
• Understand callbacks
• Handle exceptions

Use the logging module

The data that the function outputs using console.log is collected to the Logstore that is specified when a service is created. For more information about function logs, see Function logs.

exports.handler = function (event, context, callback) {
    console.info(null, 'hello world');
    callback(null, 'hello world');
};

After the preceding commands are run, the following output is displayed:

message:2017-07-05T05:13:35.920Z a72df088-f738-cee3-e0fe-323ad89118e5 [INFO] hello world

You can run the console.warn and console.error commands to package WARN and ERROR log entries, respectively.

You can change log levels using setLogLevel. The following log levels are listed in descending order of priority:

• error: indicates that the corresponding handler is console.error.
• warn: indicates that the corresponding handler is console.warn.
• info: indicates that the corresponding handler is console.info.
• verbose: indicates that the corresponding handler is console.log.
• debug: indicates that the corresponding handler is console.debug.

'use strict';
exports.handler = function(evt, ctx, cb) {
    console.setLogLevel("error");
    console.error("console error 1");
    console.info("console info 1");
    console.warn("console warn 1");
    console.log("console log 1");
    console.setLogLevel("warn");
    console.error("console error 2");
    console.info("console info 2");
    console.warn("console warn 2");
    console.log("console log 2");
    console.setLogLevel("info");
    cb(null, evt);
};

After the preceding commands are run, the following output is displayed:

message:2017-07-05T05:13:35.920Z a72df088-f738-cee3-e0fe-323ad89118e5 [ERROR] console error 1
message:2017-07-05T05:13:35.920Z a72df088-f738-cee3-e0fe-323ad89118e5 [ERROR] console error 2
message:2017-07-05T05:13:35.920Z a72df088-f738-cee3-e0fe-323ad89118e5 [WARN] console warn 2

Use built-in modules

In addition to the standard logging module, the Node.js runtime environments for Function Compute provide other modules that users can access. Currently, the modules detailed in the following table are available.

The following example uses wand to rotate an image:

var gm = require('gm').subClass({ imageMagick: true });
exports.handler = function (event, context, callback) {
    gm(event)
        .flip()
        .toBuffer('PNG', function (err, buffer) {
            if (err) return callback(err);
            callback(null, buffer);
        });
};

Note: The event parameter in the preceding function is used as the binary data of an image. The image generated subsequently is also returned in the form of binary data.

Use custom modules

If you must use a custom module, the module must be packaged with the code. For example, to add a module mysql to access MySQL using the command-line tool fcli, follow these steps:

1. Create a directory for storing code and the dependent module.

   mkdir /tmp/code

2. Create a code file named index.js and save it to the /tmp/code directory. Enter mysql in the code.

    var mysql = require('mysql');
    exports.handler = function(event, context, callback) {
      var connection = mysql.createConnection({
        host     : 'localhost',
        user     : 'me',
        password : 'secret',
        database : 'my_db'
      });
      connection.connect();
      connection.query('SELECT 1 + 1 AS solution', function (error, results, fields) {
        if (error) return callback(error);
        console.log('The solution is: ', results[0].solution);
        callback(null, results[0].solution);
      });
      connection.end();
    };

3. Install the dependency in the /tmp/code directory.

   cd /tmp/code
   npm install mysql

   After the dependency is installed, the following information is displayed in the /tmp/code directory:

   ls -l /tmp/code
   -rw-r--r--   1 rockuw  wheel  511 Aug 15 17:58 index.js
   drwxr-xr-x  13 rockuw  wheel  442 Aug 15 18:01 node_modules

4. Use fcli to create and call a function.

    ./fcli shell
    mkf my-func -h index.handler --runtime nodejs6 -d /tmp/code
    invk my-func

Use external commands

Your function may use external tools that are not developed in Node.js. For example, your function may use shell scripts or executable files compiled from C++ or Go code. In this case, you can still package them with your code and then use them by running external commands in the functions. The following example demonstrates how to run a shell script:

var exec = require('child_process');
exports.handler = function(event, context, callback) {
  var scriptPath = process.env['FC_FUNC_CODE_PATH'] + '/script.sh';
  exec.exec('bash '+scriptPath, {}, function(err, stdout, stderr) {
    if (err) return callback(err);
    console.log(stdout, stderr);
    callback(null, stdout);
  });
};

Note: Executable files compiled from C, C++, or Go code must be compatible with the runtime environment of Function Compute. The following Node.js runtime environments are supported in Function Compute:

• Linux kernel: Linux 4.4.24-2.al7.x86_64
• Docker base image: Docker Pull Node: 6.10

Understand callbacks

Node.js uses an asynchronous programming model. Therefore, your function must call a callback to return data or errors. If no callbacks are used in your function, a message is displayed, indicating that function execution has timed out.

1. Make sure that a callback is called.

If a function does not call a callback, the system assumes that the function is still being called, and waits for the function result until the operation times out. For example, when the following function is called, a timeout error is returned:

exports.handler = function(event, context, callback) {
  console.log('hello world');
};

After the preceding commands are run, the following output is displayed:

{"errorMessage":"Function timed out after 3 seconds"}

2. Function execution ends after a callback is called

After a callback is called, function execution ends. If the callback is called multiple times, only the result of the first callback takes effect. Make sure that all tasks are completed before calling the callback again. Otherwise, the remaining tasks are not executed. For example, after the following function is executed, “hello world” is returned but no “message” is displayed.

exports.handler = function(event, context, callback) {
  callback(null, 'hello world');
  callback(null, 'done');
  setTimeout(function() {
    console.log('message');
  }, 1000);
};

Handle exceptions

After a function in the Node.js runtime environment is executed, you may receive the following errors. The error type is recorded in the returned HTTP Header field X-Fc-Error-Type.

1. HandledInvocationError: error returned by the first callback parameter.
2. UnhandledInvocationError: other errors, such as an uncaught exception, a timeout error, or an out-of-memory error.

Sample 1. Return HandledInvocationError error

exports.handler = function(event, context, callback) {
  callback(new Error('oops'));
};

After the callback is called, the following output is displayed:

{
  "errorMessage": "oops",
  "errorType": "Error",
  "stackTrace": [
    "at exports.handler (/code/index.js:2:12)"
  ]
}

Sample 2. Return UnhandledInvocationError error

exports.handler = function(event, context, callback) {
  throw new Error('oops');
};

After the callback is called, the following output is displayed:

{"errorMessage":"Process exited unexpectedly before completing request"}

For more information about errors in Function Compute, see Error message.