True if we should omit the payload from the log

 ::level_of_message_with_payload the level of the message about to be logged
185250
def omit_payload_from_log?(level_of_message_with_payload)
      return true if @receive_raw_payload
      Pwwka::Logging::LEVELS[Pwwka.configuration.payload_logging.to_sym] > Pwwka::Logging::LEVELS[level_of_message_with_payload.to_sym]
    end
217036
def clear(self, payload):
        
        self.logger.rotate(self.queue)
        self.queue.clear()
        self.logger.write(self.queue)

        answer = {'message': 'Finished entries have been removed.', 'status': 'success'}
        return answer
917949
def set_log_level(self, level, keep=True):
        
        self._set_log_level(level)
        self._log_level_set_explicitly = keep
1325047
public void log(String message, Level level) {
    log(null, null, message, level);
  }
979641
def _do_log(self, client, _entry_class, payload=None, **kw):
        
        client = self._require_client(client)

        # Apply defaults
        kw["log_name"] = kw.pop("log_name", self.full_name)
        kw["labels"] = kw.pop("labels", self.labels)
        kw["resource"] = kw.pop("resource", _GLOBAL_RESOURCE)

        if payload is not None:
            entry = _entry_class(payload=payload, **kw)
        else:
            entry = _entry_class(**kw)

        api_repr = entry.to_api_repr()
        client.logging_api.write_entries([api_repr])
562189
def logger_level=(level)
      logger.level = LOGGER_LEVEL[level] if LOGGER_LEVEL.key?(level)
      logger
    end
724058
def log_message(level, message)
      if logger.respond_to?(:tagged)
        logger.tagged(TAG_NAME) { |l| l.public_send(level, message) }
      else
        logger.public_send(level, message)
      end
    end
161644
def _has_skip(self, msg):
        '''
        
        '''
        for skip in self.skips:
            if re.search(skip, msg):
                return True
        return False
121223
function(targetLevelObject, message, messageArgs)
  {
    // the message should not be logged if the target
    // level is more verbose than the current level
    if (targetLevelObject.level <= currlevelObject.level)
    {
      // substitute the messageArgs into the message template
      messageArgs.unshift(message);
      message = Util.format.apply(Util, messageArgs);

      // truncate the message if it's too long
      if (message.length > messageMaxLength)
      {
        message = message.slice(0, messageMaxLength);
      }

      // if needed, add the current time to the front of the message
      if (includeTimestamp)
      {
        message = Util.format(
            '[%s]: %s', moment().format('h:mm:ss.ms A'), message);
      }

      // log the message
      logMessage(targetLevelObject.tag, message, bufferMaxLength);
    }
  }
928822
void log(Level level, String msg) {
        if (msg != null && !msg.isEmpty())
            logger.log(level, msg);
    }
85708
def log_level(self, level):
        
        if 0 <= level <= 7:
            for i in range(level+1):
                self.add_match(PRIORITY="%d" % i)
        else:
            raise ValueError("Log level must be 0 <= level <= 7")
424239
def on_receive(self, message):
        
        if self.log_file is not None and message['should_log']:
            message_copy = Message(message['text'],
                                   Metadata(None).__dict__,
                                   message['should_log']).__dict__
            with open(self.log_file, mode='w') as f:
                f.write(json.dumps(message_copy))
            logger.info(message['metadata']['source'])
        if self.listening_for(message):
            self_thread = self.HandlerThread(self.handle, message)
            self_thread.start()
        self.cleanup()
        for child in self.children:
            child.tell(message)
199594
protected static void log(Level level, Object message, Throwable throwable, Object... args) {
		Message payload = payload(message, args, throwable);
		payload.getFormattedMessage(); // preformat message (cached), so formating has processed and added fields to MetaContext
		if (MetaContext.hasMeta()) {
			// serialize metacontext map to json, which is put into a designated threadcontext field
			ThreadContext.put(JSON_FIELD, MetaContext.toJson());
			MetaContext.clear();
		}
		determineLogger().log(level, payload, payload.getThrowable());
		if (ThreadContext.getContext() != null && ThreadContext.containsKey(JSON_FIELD)) {
			ThreadContext.remove(JSON_FIELD);
		}
	}
583814
def log(self, message, level=logging.INFO, *args, **kwargs):
        
        msg = "{}.{}: {}[{}]: {}".format(
            self.__class__.__name__, self.status, self.__class__.path,
            self.uuid, message
        )
        extra = kwargs.pop("extra", dict())
        extra.update(dict(kmsg=Message(
            self.uuid, entrypoint=self.__class__.path, params=self.params,
            metadata=self.metadata
        ).dump()))

        return logger.log(
            level=level, msg=msg, extra=extra, *args, **kwargs
        )
996135
def log_end_message(log):
    
    if not log in MESSAGE_LOG.keys():
        log = -1

    res = colors.color_text(*MESSAGE_LOG[log][1])

    sys.stdout.write("\r[" + res + "] " + MESSAGE + "\n")
1011425
function logtap(logger, message, data) {
  data = _.clone(data);
  if (data.payload_binary) {
    data.payload_binary = '... (' + data.payload_binary.length + ' bytes)';
  }
  logger.debug(message, data);
}
1196987
private boolean checkMisroutedIv2IntiateTaskMessage(Iv2InitiateTaskMessage message) {
        if (message.isForReplica()) {
            return false;
        }

        if (m_scheduler.isLeader() && m_migratePartitionLeaderStatus != MigratePartitionLeaderStatus.TXN_RESTART) {
            //At this point, the message is sent to partition leader
            return false;
        }

        //At this point, the message is misrouted.
        //(1) If a site has been demoted via @MigratePartitionLeader, the messages which are sent to the leader will be restarted.
        //(2) If a site becomes new leader via @MigratePartitionLeader. Transactions will be restarted before it gets notification from old
        //    leader that transactions on older leader have been drained.
        InitiateResponseMessage response = new InitiateResponseMessage(message);
        response.setMisrouted(message.getStoredProcedureInvocation());
        response.m_sourceHSId = getHSId();
        deliver(response);
        if (tmLog.isDebugEnabled()) {
            tmLog.debug("Sending message back on:" + CoreUtils.hsIdToString(m_hsId) + " isLeader:" + m_scheduler.isLeader() +
                    " status:" + m_migratePartitionLeaderStatus + "\n" + message);
        }
        //notify the new partition leader that the old leader has completed the Txns if needed.
        notifyNewLeaderOfTxnDoneIfNeeded();
        return true;
    }