net.i2p.router

## Class MessageHistory

- java.lang.Object
- - net.i2p.router.MessageHistory

-     public class MessageHistory
      extends Object

  Logs router message traffic for debugging and network analysis. Records inbound and outbound messages with timestamps when enabled, providing detailed traffic history for troubleshooting.

  This is always instantiated in context and WriteJob runs every minute, (except on Android, we don't set up the WriteJob) but unless router.keepHistory=true it does nothing. It generates a LARGE log file.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static String` | `DEFAULT_MESSAGE_HISTORY_FILENAME`
    `static String` | `PROP_KEEP_MESSAGE_HISTORY` config property determining whether we want to debug with the message history - default false
    `static String` | `PROP_MESSAGE_HISTORY_FILENAME` config property determining where we want to log the message history, if we're keeping one

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `MessageHistory(RouterContext context)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `banlist(Hash peer, String reason)` We banlisted the peer
    `void` | `droppedFragmentedMessage(long messageId, String status)`
    `void` | `droppedInboundMessage(long messageId, Hash from, String info)`
    `void` | `droppedOtherMessage(I2NPMessage message, Hash from)` We received another message we weren't waiting for and don't know how to handle
    `void` | `droppedTunnelDataMessageUnknown(long msgId, long tunnelId)`
    `void` | `droppedTunnelGatewayMessageUnknown(long msgId, long tunnelId)`
    `void` | `droppedTunnelMessage(TunnelId id, long msgId, Date expiration, Hash from)` We don't know about the given tunnel, so we are dropping a message sent to us by the given router
    `void` | `fragmentMessage(long messageId, int numFragments, int totalLength, List<Long> messageIds, Object tunnel, String msg)`
    `void` | `fragmentMessage(long messageId, int numFragments, int totalLength, List<Long> messageIds, String msg)`
    `boolean` | `getDoLog()`
    `(package private) String` | `getFilename()`
    `void` | `initialize(boolean forceReinitialize)` Initialize the message history according to the router's configuration.
    `void` | `messageProcessingError(long messageId, String messageType, String error)` There was an error processing the given message that was received
    `void` | `receiveMessage(String messageType, long messageId, long expiration, boolean isValid)`
    `void` | `receiveMessage(String messageType, long messageId, long expiration, Hash from, boolean isValid)` We just received a message from the peer
    `void` | `receivePayloadMessage(long messageId)` Receive a payload message to distribute to a client
    `void` | `receiveTunnelFragment(long messageId, int fragmentId, Object status)`
    `void` | `receiveTunnelFragmentComplete(long messageId)`
    `void` | `replyTimedOut(OutNetMessage sentMessage)` The message wanted a reply but no reply came in the time expected
    `void` | `sendMessage(String messageType, long messageId, long expiration, Hash peer, boolean sentOk, String info)` We just sent a message to the peer
    `void` | `sendPayloadMessage(long messageId, boolean successfullySent, long timeToSend)` Note that the sending of a payload message completed (successfully or as a failure)
    `void` | `shutdown()`
    `void` | `tunnelDispatched(long messageId, long tunnelId, long toTunnel, Hash toPeer, String type)`
    `void` | `tunnelDispatched(long messageId, long innerMessageId, long tunnelId, String type)`
    `void` | `tunnelDispatched(long messageId, long tunnelId, String type)`
    `void` | `tunnelDispatched(String info)`
    `void` | `tunnelFailed(TunnelId tunnel)` The local router has detected a failure in the given tunnel
    `void` | `tunnelJoined(String state, HopConfig tunnel)` The local router has joined the given tunnel operating in the given state.
    `void` | `tunnelJoined(String state, TunnelInfo tunnel)` The local router has joined the given tunnel operating in the given state.
    `void` | `tunnelParticipantRejected(Hash peer, String msg)`
    `void` | `tunnelRejected(Hash peer, TunnelId tunnel, Hash replyThrough, String reason)` The peer did not accept the tunnel join for the given reason
    `void` | `tunnelRequestTimedOut(Hash peer, TunnelId tunnel)` The peer did not accept the tunnel join for the given reason (this may be because of a timeout or an explicit refusal).
    `void` | `tunnelValid(TunnelInfo tunnel, long timeToTest)` Note that we have reason to believe that the given tunnel is valid, since we could do something through it in the given amount of time
    `void` | `unbanlist(Hash peer)` We unbanlisted the peer
    `void` | `wrap(String bodyMessageType, long bodyMessageId, String containerMessageType, long containerMessageId)` Note that we're wrapping the given message within another message (via tunnel/garlic)

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### DEFAULT_MESSAGE_HISTORY_FILENAME

          public static final String DEFAULT_MESSAGE_HISTORY_FILENAME

      See Also:
        Constant Field Values

    - #### PROP_KEEP_MESSAGE_HISTORY

          public static final String PROP_KEEP_MESSAGE_HISTORY

      config property determining whether we want to debug with the message history - default false
      See Also:
        Constant Field Values

    - #### PROP_MESSAGE_HISTORY_FILENAME

          public static final String PROP_MESSAGE_HISTORY_FILENAME

      config property determining where we want to log the message history, if we're keeping one
      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### MessageHistory

          public MessageHistory(RouterContext context)

  - ### Method Detail

    - #### banlist

          public void banlist(Hash peer,
                              String reason)

      We banlisted the peer

    - #### droppedFragmentedMessage

          public void droppedFragmentedMessage(long messageId,
                                               String status)

    - #### droppedInboundMessage

          public void droppedInboundMessage(long messageId,
                                            Hash from,
                                            String info)

    - #### droppedOtherMessage

          public void droppedOtherMessage(I2NPMessage message,
                                          Hash from)

      We received another message we weren't waiting for and don't know how to handle

    - #### droppedTunnelDataMessageUnknown

          public void droppedTunnelDataMessageUnknown(long msgId,
                                                      long tunnelId)

    - #### droppedTunnelGatewayMessageUnknown

          public void droppedTunnelGatewayMessageUnknown(long msgId,
                                                         long tunnelId)

    - #### droppedTunnelMessage

          public void droppedTunnelMessage(TunnelId id,
                                           long msgId,
                                           Date expiration,
                                           Hash from)

      We don't know about the given tunnel, so we are dropping a message sent to us by the given router
      Parameters:
        `id` - tunnel ID we received a message for
        `from` - peer that sent us this message (if known)

    - #### fragmentMessage

          public void fragmentMessage(long messageId,
                                      int numFragments,
                                      int totalLength,
                                      List<Long> messageIds,
                                      Object tunnel,
                                      String msg)

    - #### fragmentMessage

          public void fragmentMessage(long messageId,
                                      int numFragments,
                                      int totalLength,
                                      List<Long> messageIds,
                                      String msg)

    - #### getDoLog

          public boolean getDoLog()

    - #### getFilename

          String getFilename()

    - #### initialize

          public void initialize(boolean forceReinitialize)

      Initialize the message history according to the router's configuration. Call this whenever the router identity changes.

    - #### messageProcessingError

          public void messageProcessingError(long messageId,
                                             String messageType,
                                             String error)

      There was an error processing the given message that was received
      Parameters:
        `messageId` - message received
        `messageType` - type of message received
        `error` - error message related to the processing of the message

    - #### receiveMessage

          public void receiveMessage(String messageType,
                                     long messageId,
                                     long expiration,
                                     boolean isValid)

    - #### receiveMessage

          public void receiveMessage(String messageType,
                                     long messageId,
                                     long expiration,
                                     Hash from,
                                     boolean isValid)

      We just received a message from the peer
      Parameters:
        `messageType` - class name for the message object (e.g. DatabaseFindNearestMessage, TunnelMessage, etc)
        `messageId` - the unique message id of the message received (not including any tunnel or garlic wrapped message ids)
        `expiration` - the expiration for the message received
        `from` - router that the message was sent from (or null if we don't know)
        `isValid` - whether the message is valid (non duplicates, etc)

    - #### receivePayloadMessage

          public void receivePayloadMessage(long messageId)

      Receive a payload message to distribute to a client

    - #### receiveTunnelFragment

          public void receiveTunnelFragment(long messageId,
                                            int fragmentId,
                                            Object status)

    - #### receiveTunnelFragmentComplete

          public void receiveTunnelFragmentComplete(long messageId)

    - #### replyTimedOut

          public void replyTimedOut(OutNetMessage sentMessage)

      The message wanted a reply but no reply came in the time expected
      Parameters:
        `sentMessage` - message sent that didn't receive a reply

    - #### sendMessage

          public void sendMessage(String messageType,
                                  long messageId,
                                  long expiration,
                                  Hash peer,
                                  boolean sentOk,
                                  String info)

      We just sent a message to the peer
      Parameters:
        `messageType` - class name for the message object (e.g. DatabaseFindNearestMessage, TunnelMessage, etc)
        `messageId` - the unique message id of the message being sent (not including any tunnel or garlic wrapped message ids)
        `expiration` - the expiration for the message sent
        `peer` - router that the message was sent to
        `sentOk` - whether the message was sent successfully

    - #### sendPayloadMessage

          public void sendPayloadMessage(long messageId,
                                         boolean successfullySent,
                                         long timeToSend)

      Note that the sending of a payload message completed (successfully or as a failure)
      Parameters:
        `messageId` - message that the payload message was sent in
        `successfullySent` - whether the message was delivered to the peer successfully
        `timeToSend` - how long it took to send the message

    - #### shutdown

          public void shutdown()

    - #### tunnelDispatched

          public void tunnelDispatched(long messageId,
                                       long tunnelId,
                                       long toTunnel,
                                       Hash toPeer,
                                       String type)

    - #### tunnelDispatched

          public void tunnelDispatched(long messageId,
                                       long innerMessageId,
                                       long tunnelId,
                                       String type)

    - #### tunnelDispatched

          public void tunnelDispatched(long messageId,
                                       long tunnelId,
                                       String type)

    - #### tunnelDispatched

          public void tunnelDispatched(String info)

    - #### tunnelFailed

          public void tunnelFailed(TunnelId tunnel)

      The local router has detected a failure in the given tunnel
      Parameters:
        `tunnel` - tunnel failed

    - #### tunnelJoined

          public void tunnelJoined(String state,
                                   HopConfig tunnel)

      The local router has joined the given tunnel operating in the given state.
      Parameters:
        `state` - {"free inbound", "allocated inbound", "inactive inbound", "outbound", "participant", "pending"}
        `tunnel` - tunnel joined

    - #### tunnelJoined

          public void tunnelJoined(String state,
                                   TunnelInfo tunnel)

      The local router has joined the given tunnel operating in the given state.
      Parameters:
        `state` - {"free inbound", "allocated inbound", "inactive inbound", "outbound", "participant", "pending"}
        `tunnel` - tunnel joined

    - #### tunnelParticipantRejected

          public void tunnelParticipantRejected(Hash peer,
                                                String msg)

    - #### tunnelRejected

          public void tunnelRejected(Hash peer,
                                     TunnelId tunnel,
                                     Hash replyThrough,
                                     String reason)

      The peer did not accept the tunnel join for the given reason

    - #### tunnelRequestTimedOut

          public void tunnelRequestTimedOut(Hash peer,
                                            TunnelId tunnel)

      The peer did not accept the tunnel join for the given reason (this may be because of a timeout or an explicit refusal).

    - #### tunnelValid

          public void tunnelValid(TunnelInfo tunnel,
                                  long timeToTest)

      Note that we have reason to believe that the given tunnel is valid, since we could do something through it in the given amount of time
      Parameters:
        `tunnel` - tunnel in question
        `timeToTest` - milliseconds to verify the tunnel

    - #### unbanlist

          public void unbanlist(Hash peer)

      We unbanlisted the peer

    - #### wrap

          public void wrap(String bodyMessageType,
                           long bodyMessageId,
                           String containerMessageType,
                           long containerMessageId)

      Note that we're wrapping the given message within another message (via tunnel/garlic)
      Parameters:
        `bodyMessageType` - class name for the message contained (e.g. DatabaseFindNearestMessage, DataMessage, etc)
        `bodyMessageId` - the unique message id of the message
        `containerMessageType` - class name for the message containing the body message (e.g. TunnelMessage, GarlicMessage, etc)
        `containerMessageId` - the unique message id of the message