Writes the supplied message from the running script to the log.
@param {String} script - the name of the running script.
@param {String} msg - the message.
@param {Boolean} isError - indicates if the message is an error message.
329353
function scriptLog(script, msg, isError) {
	write(msg, 
		isError ? clc.red : null, 
		clc.yellow('[' + script + ']'));
}
176443
function (errors, throwsErrors) {
                if (errors.length === 0) {
                    return true;
                }
                if (!throwsErrors) {
                    for (var i = 0; i < errors.length; i++) {
                        this.$logError(errors[i].msgId, errors[i].msgArgs);
                    }
                } else {
                    var error, logs = aria.core.Log;
                    // aria.core.Log may not be available
                    if (logs) {
                        var messages = [];
                        for (var i = 0; i < errors.length; i++) {
                            errors[i].message = logs.prepareLoggedMessage(errors[i].msgId, errors[i].msgArgs);
                            messages.push(errors[i].message);
                        }
                        error = new Error(messages.join('\n'));
                    } else {
                        error = new Error();
                    }
                    error.errors = errors;
                    throw error;
                }
                return false;
            }
32061
function (error) {
        if (!this.started) {
            return;
        }

        var errorHandlers = this.errorHandlers,
            length = errorHandlers.length,
            errorHandler,
            errorHandled = false,
            errorString,
            i;

        //Exit handling
        if (error instanceof SystemExit) {
            this._exit(error.code);
            return;
        }

        try {
            for (i = 0; i < length; i += 1) {
                errorHandler = errorHandlers[i];
                errorHandled = !!errorHandler(error);

                if (errorHandled) {
                    return;
                }
            }
        } catch (e) {
            this._printError(e);
            this._exit(1);
        }

        //Default error handling
        errorString = '' + (error.stack || error);
        this._printError(errorString);
        this._exit(1);
    }
1130182
def setError(self, msg=None, title=None):
        
        if msg is not None:
            self.messageLabel.setText(msg)

        if title is not None:
            self.titleLabel.setText(title)
288331
def write(self, script):
        # type: (str) -> None
        
        if self._closed:
            raise IOError('tried to write to closed connection')
        script = script.strip()
        if script:
            assert self._parentout is not None
            self._parentout.write(script)
            self._parentout.write('\n')
1262439
function errmsg(msg) {
  const obj = this._obj,
        errorMessages = getErrorMessages(obj);
  this.assert(
    _.includes(errorMessages, msg),
    'expected #{this} to have an error message: #{errmsg}',
    'expected #{this} to not an error message: #{errmsg}',
    msg,   // expected
    errorMessages   // actual
  );
}
1168981
function ScriptRunner() {
  this.flush();

  function onMessage(msg, handle) {
    var script, digest;
    switch(msg.event) {
      case 'loglevel':
        log.level(msg.level);
        break;
      case 'eval':
        try {
          script = this.load(msg.source).script;
          this.run(script, msg.args);
        }catch(e) {
          process.send({err: true, data: e.message});
        }
        break;
      case 'evalsha':
        try {
          script = this._cache[msg.sha];
          if(!script) throw NoScript;
          this.run(script, msg.args);
        }catch(e) {
          process.send({err: true, data: e.message});
        }
        break;
      case 'load':
        try {
          digest = this.load(msg.source).sha;
          process.send({data: digest});
        }catch(e) {
          process.send({err: true, data: e.message});
        }
        break;
      case 'exists':
        process.send({data: this.exists(msg.args)});
        break;
      case 'flush':
        this.flush();
        process.send({data: Constants.OK});
        break;
    }
  }

  process.on('message', onMessage.bind(this));
}
1121719
public void script(String line, DispatchCallback callback) {
    if (sqlLine.getScriptOutputFile() == null) {
      startScript(line, callback);
    } else {
      stopScript(line, callback);
    }
  }
482778
public void processError(String msg) {
        synchronized (frameListeners) {
            Iterator<FrameListener> it = frameListeners.iterator();
            while (it.hasNext()) {
                FrameListener listener = it.next();
                listener.processError(msg);
            }
        }
    }
1157625
protected final void addError(String msgKey, Object... args) {
    getFlash().addErrorNow(getTextInternal(msgKey, args));
  }
1358047
public void setPostTransScript( final String script) {
		setPostTransProgram(readProgram(script));
		if ( script != null) format.getHeader().createEntry( POSTTRANSSCRIPT, script);
	}
1287527
function(msg) {
            var event = _getEvent.apply(this, arguments);

            var data = {event: event};

            // Add agent info if required
            if (_pageInfo !== 'never') {
                if (!_sentPageInfo || _pageInfo === 'per-entry') {
                    _sentPageInfo = true;
                    if (typeof event.screen === "undefined" &&
                        typeof event.browser === "undefined")
                      _rawLog(_agentInfo()).level('PAGE').send();
                }
            }

            if (_traceCode) {
                data.trace = _traceCode;
            }

            return {level: function(l) {
                // Don't log PAGE events to console
                // PAGE events are generated for the agentInfo function
                    if (_print && typeof console !== "undefined" && l !== 'PAGE') {
                      var serialized = null;
                      if (typeof XDomainRequest !== "undefined") {
                        // We're using IE8/9
                        serialized = data.trace + ' ' + data.event;
                      }
                      try {
                        console[l.toLowerCase()].call(console, (serialized || data));
                      } catch (ex) {
                        // IE compat fix
                        console.log((serialized || data));
                      }
                    }
                    data.level = l;

                    return {send: function() {
                        var cache = [];
                        var serialized = JSON.stringify(data, function(key, value) {

                              if (typeof value === "undefined") {
                                return "undefined";
                              } else if (typeof value === "object" && value !== null) {
                                if (_indexOf(cache, value) !== -1) {
                                  // We've seen this object before;
                                  // return a placeholder instead to prevent
                                  // cycles
                                  return "<?>";
                                }
                                cache.push(value);
                              }
                          return value;
                        });

                            if (_active) {
                                _backlog.push(serialized);
                            } else {
                                _apiCall(_token, serialized);
                            }
                        }};
                }};
        }
324218
function validateScript(script) {
  var valid = this._validate(script);
  validateScript.errors = this._validate.errors;
  return valid;
}
727429
public void error(String msg, Throwable t)
	{
		log(LogLevel.ERROR, msg, t);
	}
334076
@Override
  @SuppressWarnings("FutureReturnValueIgnored")
  public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) {
    if (failCause != null) {
      promise.setFailure(failCause);
      ReferenceCountUtil.release(msg);
    } else {
      bufferedWrites.add(new ChannelWrite(msg, promise));
    }
  }
440549
function(msg, url, line){
		var message = "Error in (" + (url || window.location) + ") on line "+ line +" with message (" + msg + ")";
		this.log(Log4js.Level.FATAL, message, null);	
	}
1269320
def error(self, msg):
        
        self._execActions('error', msg)
        msg = self._execFilters('error', msg)
        self._processMsg('error', msg)
        self._sendMsg('error', msg)