anchor.diff:              :: node(),
           logger_self
               :: pid(),
  +        mode_sync_start = undefined
  +            :: undefined | cloudi_timestamp:native_monotonic(),
  +        mode_sync_start_event = undefined
  +            :: undefined | cloudi_timestamp:iso8601(),
  +        mode_sync_end = undefined
  +            :: undefined | cloudi_timestamp:native_monotonic(),
  +        mode_sync_end_event = undefined
  +            :: undefined | cloudi_timestamp:iso8601(),
  +        mode_sync_total = undefined
  +            :: undefined | cloudi_service_api:nanoseconds_string(),
  +        mode_overload_start = undefined
  +            :: undefined | cloudi_timestamp:native_monotonic(),
  +        mode_overload_start_event = undefined
  +            :: undefined | cloudi_timestamp:iso8601(),
  +        mode_overload_end = undefined
  +            :: undefined | cloudi_timestamp:native_monotonic(),
  +        mode_overload_end_event = undefined
  +            :: undefined | cloudi_timestamp:iso8601(),
  +        mode_overload_total = undefined
  +            :: undefined | cloudi_service_api:nanoseconds_string(),
           file_counts = #{}
               :: #{cloudi_service_api:loglevel() := pos_integer()},
           error_read_count = 0
  
positive.code:     {ok, State#state{queue_pending = QueuePending - 1}}.
  
  log_mode_changed(sync, async, Timestamp, State) ->
      {ok, State#state{sync_start = cloudi_timestamp:native_monotonic(),
                       sync_start_event = timestamp_iso8601(Timestamp),
                       sync_end = undefined,
                       sync_end_event = undefined,
                       sync_total = undefined}};
  log_mode_changed(async, sync, Timestamp,
                   #state{sync_start = SyncStart} = State) ->
      SyncEnd = cloudi_timestamp:native_monotonic(),
      SyncNanoSeconds = cloudi_timestamp:
                        convert(SyncEnd - SyncStart,
                                native, nanosecond),
      SyncTotal = cloudi_timestamp:
                  nanoseconds_to_string(SyncNanoSeconds),
      {ok, State#state{sync_end = SyncEnd,
                       sync_end_event = timestamp_iso8601(Timestamp),
                       sync_total = SyncTotal}};
  log_mode_changed(overload, sync, Timestamp, State) ->
      {ok, State#state{overload_start = cloudi_timestamp:native_monotonic(),
                       overload_start_event = timestamp_iso8601(Timestamp),
                       overload_end = undefined,
                       overload_end_event = undefined,
                       overload_total = undefined}};
  log_mode_changed(sync, overload, Timestamp,
                   #state{overload_start = OverloadStart} = State) ->
      OverloadEnd = cloudi_timestamp:native_monotonic(),
      OverloadNanoSeconds = cloudi_timestamp:
                            convert(OverloadEnd - OverloadStart,
                                    native, nanosecond),
      OverloadTotal = cloudi_timestamp:
                      nanoseconds_to_string(OverloadNanoSeconds),
      StateNew = State#state{overload_end = OverloadEnd,
                             overload_end_event = timestamp_iso8601(Timestamp),
                             overload_total = OverloadTotal},
      ?LOG_T0_ERROR("logging overload occurred for ~s",
                    [OverloadTotal], StateNew);
  log_mode_changed(_, _, _, State) ->
  
negative.code:     end;
  handle_call(status, _,
              #state{mode = Mode,
                     mode_sync_start = SyncStart,
                     mode_sync_start_event = SyncStartEvent,
                     mode_sync_end = SyncEnd,
                     mode_sync_end_event = SyncEndEvent,
                     mode_sync_total = SyncTotal,
                     mode_overload_start = OverloadStart,
                     mode_overload_start_event = OverloadStartEvent,
                     mode_overload_end = OverloadEnd,
                     mode_overload_end_event = OverloadEndEvent,
                     mode_overload_total = OverloadTotal,
                     file_counts = FileCounts,
                     error_read_count = ErrorReadCount,
                     error_read_types = ErrorReadTypes,
                     error_write_count = ErrorWriteCount,
                     error_write_types = ErrorWriteTypes,
                     error_sync_count = ErrorSyncCount,
                     error_sync_types = ErrorSyncTypes} = State) ->
      TimeOffset = erlang:time_offset(),
      Status0 = if
          ErrorReadCount > 0 ->
  