Take the log of each entry.
185645
public void log() {
        for (int c=0; c<this.values.length; c++) {
            this.values[c] = s.log(this.values[c]);
        }
    }
931378
def ReadFlowLogEntries(self,
                         client_id,
                         flow_id,
                         offset,
                         count,
                         with_substring=None):
    """"""
    entries = sorted(
        self.flow_log_entries.get((client_id, flow_id), []),
        key=lambda e: e.timestamp)

    if with_substring is not None:
      entries = [i for i in entries if with_substring in i.message]

    return entries[offset:offset + count]
107717
def _load_entries(self, root):
        """"""
        mdict = {
            "comments": self._comment,
            "line": self._line,
            "group": self._group
        }
        for entry in root:
            mdict[entry.tag](entry)
595680
public static void logResults() {
        for (Entry<String, Counter> e : CUMULATED.entrySet()) {
            LOGGER.logProfilingInfo(e.getValue());
        }
    }
1103636
def _prune_entries(self, num):
        ""
        while num > 0:
            self.access_log_lock.acquire()
            p = self.access_log.pop()
            self.access_log_lock.release()

            if not p.is_valid:
                continue # Invalidated entry, skip

            dict.pop(self, p.key, None)
            self.access_lookup.pop(p.key, None)
            num -= 1
1030562
def log_vars(self, message, variables, rem_vars=("self",)):
        """"""
        if self.verbose:
            new_vars = dict(variables)
            for v in rem_vars:
                del new_vars[v]
            printerr(message, new_vars)
1115700
def log(self, *args):
        """"""
        if _canShortcutLogging(self.logCategory, LOG):
            return
        logObject(self.logObjectName(), self.logCategory,
            *self.logFunction(*args))
142189
def get_log(self, offset, count=10, callback=None):
        '''
        
        '''
        params = {'offset': offset, 'count': count}
        return self.execute_command('getLog', params, callback=callback)
851216
def process_log_event(event, context):
    """"""
    init()
    serialized = event['awslogs'].pop('data')
    data = json.loads(zlib.decompress(
        base64.b64decode(serialized), 16 + zlib.MAX_WBITS))

    # Fetch additional logs for context (20s window)
    timestamps = [e['timestamp'] for e in data['logEvents']]
    start = min(timestamps) - 1000 * 15
    end = max(timestamps) + 1000 * 5

    events = logs.get_log_events(
        logGroupName=data['logGroup'],
        logStreamName=data['logStream'],
        startTime=start,
        endTime=end,
        startFromHead=True)['events']

    message = [
        "An error was detected",
        "",
        "Log Group: %s" % data['logGroup'],
        "Log Stream: %s" % data['logStream'],
        "Log Owner: %s" % data['owner'],
        "",
        "Log Contents",
        ""]

    # We may get things delivered from log sub that are not in log events
    for evt in data['logEvents']:
        if evt not in events:
            events.append(evt)

    for evt in events:
        message.append(message_event(evt))
        message.append("")

    params = dict(
        TopicArn=config['topic'],
        Subject=config['subject'],
        Message='\n'.join(message))

    sns.publish(**params)
377808
def bulk_log_data(registers = register_list)
      registers.map do |reg|
        read_scaled_range(reg.start, reg.count)
      end.flatten
    end
1105383
def build_usage_logger(self, log):
        ''''''
        def _log_usage():
            log.debug("{}mb peak memory", peak_memory())
            log.debug("{} pending alignment pairs; {} peak pairs",
                      self.pending_pair_count,
                      self.pending_pair_peak_count)
        return _log_usage
657624
def merge_logs(dataset, sort=True):
    """"""
    ourlog = {}
    ourlog['entries'] = []
    for d in dataset:
        ourlog['entries'] = ourlog['entries'] + d['entries']
    if sort:
        ourlog['entries'].sort(key= lambda x: x['numeric_date_stamp_utc'])

    return ourlog
89529
def addLogEntry(self, entry, save=True):
        """"""
        # create log directory if it doesn't exist
        # error will be thrown if this is not possible
        _busy = Purr.BusyIndicator()
        self._initIndexDir()
        # discard temporary watchers -- these are only used to keep track of
        # deleted files
        self.temp_watchers = {}
        # ignored entries are only there to carry info on ignored data products
        # All we do is save them, and update DP policies based on them
        if entry.ignore:
            entry.save(self.logdir)
        # proper entries are added to list
        else:
            self.entries.append(entry)
            Purr.progressMessage("Saving new log entry")
            # find previous entry -- skip over "ignore" entries
            for prev in self.entries[-2::-1]:
                if not prev.ignore:
                    break
            else:
                prev = None
            entry.setLogDirectory(self.logdir)
            entry.setPrevUpNextLinks(prev=prev, up=os.path.join("..", Purr.RenderIndex.INDEX))
            entry.save()
            self.timestamp = self.last_scan_timestamp
            # regenerate links of previous entry
            prev and prev.generateIndex()
            # and our log may need to be regenerated
            if save:
                self.save()
        self.updatePoliciesFromEntry(entry, new=True)
542895
function processLogs() {
  var calcs = 0;
  for (var i in stats) {
    stats[i].average = stats[i].totalTime / stats[i].count;
    calcs += stats[i].calcs;
  }
  var time1 = meaningfulTime();
  var time2 = meaningfulTime();
  console.error("TRACER TOTAL OVERHEAD", (calcs*timeDiff(time2, time1)).toFixed(2)+'ms');

  while (Object.keys(stats).length > 0) {
    var biggest = 0;
    var biggestPath = Object.keys(stats)[0];
    for (var path in stats) {
      if (stats[path].average >= biggest) {
        biggestPath = path;
        biggest = stats[path].average;
      }
    }
    console.error("TRACER TOTAL",
                  stats[biggestPath].min.toFixed(2)+'ms',
                  stats[biggestPath].average.toFixed(2)+'ms',
                  stats[biggestPath].max.toFixed(2)+'ms',
                  stats[biggestPath].count,
                  biggestPath);
    delete stats[biggestPath];
  }
}
1161080
def log(self, *args, **kwargs):
        """"""
        if self.verbose:
            print('   ' * self.depth, *args, **kwargs)
1145582
def use_plenary_log_entry_view(self):
        """"""
        self._object_views['log_entry'] = PLENARY
        # self._get_provider_session('log_entry_lookup_session') # To make sure the session is tracked
        for session in self._get_provider_sessions():
            try:
                session.use_plenary_log_entry_view()
            except AttributeError:
                pass
27989
private void log(ArrayList<PrintWriter> writers, RecordTypes recordType,
                   Keys[] keys, String[] values) {
    log(writers, recordType, keys, values, false);
  }