How to use the log.error function in log

} else {
                if (error.error instanceof Error) {
                    error.stack = (error.error.stack) ? error.error.stack : undefined;
                    error.error = error.error.message;
                } else if (error instanceof client.Response) {
                    error = error.getLog();
                }
                try {
                    // encode
                    return $('<div>').text(JSON.stringify(error, null, 4)).html();
                } catch (e) {
                    return error.toString();
                }
            }
        } catch (e) {
            log.error(e);
        }
    };
</div>

this._$designViewContainer = container;
        var canvasContainer = $('<div></div>');
        canvasContainer.addClass(_.get(viewOptions, 'cssClass.canvas_container'));
        var canvasTopControlsContainer = $('<div></div>')
            .addClass(_.get(viewOptions, 'cssClass.canvas_top_controls_container'))
            .append($('<div></div>').addClass(_.get(viewOptions, 'cssClass.canvas_top_control_package_define')))
            .append($('<div></div>').addClass(_.get(viewOptions, 'cssClass.canvas_top_control_packages_import')))
            .append($('<div></div>').addClass(_.get(viewOptions, 'cssClass.canvas_top_control_constants_define')));
        canvasContainer.append(canvasTopControlsContainer);

        this._$designViewContainer.append(canvasContainer);
        this._$canvasContainer = canvasContainer;
        // check whether container element exists in dom
        if (!container.length &gt; 0) {
            errMsg = 'unable to find container for file composer with selector: ' + _.get(viewOptions, 'design_view.container');
            log.error(errMsg);
            throw errMsg;
        }

        var toolPaletteItemProvider = new ToolPaletteItemProvider();
        var toolPaletteContainer = $(this._container)
                                    .find(_.get(viewOptions, 'design_view.tool_palette.container'))
                                    .get(0);
        var toolPaletteOpts = _.clone(_.get(viewOptions, 'design_view.tool_palette'));
        toolPaletteOpts.itemProvider = toolPaletteItemProvider;
        toolPaletteOpts.container = toolPaletteContainer;
        toolPaletteOpts.ballerinaFileEditor = this;
        this.toolPalette = new ToolPalette(toolPaletteOpts);

        this._createImportDeclarationPane(canvasContainer);

        // init undo manager

goToSource(node) {
        if (!_.isNil(node)) {
            const { position, type } = node;
            // If node has position info
            if (position) {
                const { startLine, startColumn } = position;
                this.jumpToSourcePosition(startLine - 1, startColumn - 1);
            } else {
                log.error(`Unable to find location info from ${type} node.`);
            }
        } else {
            log.error('Invalid node to find source line.');
        }
    }

setBType(type, options) {
        if (!_.isUndefined(type)) {
            this.setAttribute('_bType', type, options);
        } else {
            const exceptionString = 'A variable requires a type.';
            log.error(exceptionString);
            throw exceptionString;
        }
    }

nodeName = nodeExpression.getOperatorKind();
            paramExpressions.push(nodeExpression.getLeftExpression());
            paramExpressions.push(nodeExpression.getRightExpression());
        } else if (TreeUtil.isUnaryExpr(nodeExpression)) {
            nodeDef = this.transformNodeManager.getOperatorVertices(nodeExpression);
            nodeName = nodeExpression.getOperatorKind();
            paramExpressions.push(nodeExpression.getExpression());
        } else if (this.transformNodeManager.isTransformerConversion(parentNodeExpression)) {
            nodeDef = this.transformNodeManager.getConversionVertices(parentNodeExpression);
            nodeName = parentNodeExpression.getTransformerInvocation().getName().getValue();
            paramExpressions.push(parentNodeExpression.getExpression());
            paramExpressions = paramExpressions.concat(parentNodeExpression
                                .getTransformerInvocation().getArgumentExpressions());
            nodeExpID = parentNodeExpression.getID();
        } else {
            log.error('Invalid node type ' + nodeExpression.kind);
            return;
        }

        if (_.isUndefined(nodeDef)) {
            this.context.alert.showError('Function definition for "' + nodeName + '" cannot be found');
            return;
        }

        if (nodeDef.parameters.length !== paramExpressions.length) {
            this.context.alert.showWarning('Function inputs and mapping count does not match in "' + nodeName + '"');
        }

        if (receiver) {
            this.drawReceiverConnection(receiver, statement, nodeExpression, nodeDef);
        }

.catch((error) => {
                            log.error(error.message);
                            onSaveFail(error.message);
                        });
                }

fragment = FragmentUtils.createArgumentParameterFragment(value);
        } else {
            type = 'returnParameter';
            fragment = FragmentUtils.createReturnParameterFragment(value);
        }
        const parsedJson = FragmentUtils.parseFragment(fragment);
        if ((!_.has(parsedJson, 'error') && !_.has(parsedJson, 'syntax_errors'))) {
            if (_.isEqual(parsedJson.kind, 'Variable')) {
                const newNode = TreeBuilder.build(parsedJson);
                if (type === 'argumentParameter') {
                    this.parent.replaceParameters(oldNode, newNode);
                } else {
                    this.parent.replaceReturnParameters(oldNode, newNode);
                }
            } else {
                log.error('Error while parsing parameter. Error response' + JSON.stringify(parsedJson));
            }
        } else {
            log.error('Error while parsing parameter. Error response' + JSON.stringify(parsedJson));
        }
    }

setOnConnectInstance(onConnectInstance) {
        if (!_.isNil(onConnectInstance)) {
            this._onConnectInstance = onConnectInstance;
        } else {
            log.error('Invalid onConnectInstance [' + onConnectInstance + '] Provided');
            throw 'Invalid onConnectInstance [' + onConnectInstance + '] Provided';
        }
    }

removeOperatorToOperatorMapping(source, target) {
        const assignmentStmt = this.getParentStatement(target.operator);
        const newAssignIndex = this._transformStmt.body.getIndexOfStatements(assignmentStmt);

        const setter = this.getOperandSetterFunction(target.operator, target.index);
        if (!setter) {
            log.error('Unknown operator type for mapping');
            return;
        }
        setter(TransformerFactory.createDefaultExpression(target.type), true);

        const newAssignmentStmt = this.createNewAssignment(source.operator);
        this._transformStmt.body.addStatements(newAssignmentStmt, newAssignIndex, true);

        this._transformStmt.trigger('tree-modified', {
            origin: this._transformStmt,
            type: 'transform-connection-removed',
            title: `Remove mapping ${source.operator.getOperatorKind()} to ${target.operator.getOperatorKind()}`,
            data: {},
        });
    }

setName(name) {
        if (!_.isNil(name) && _.isString(name)) {
            this._name = name;
        } else {
            log.error('Invalid value for package name: ', name);
        }
    }