anchor.diff:  -spec(publish(queue_type(), any(), any(), any()) ->
                ok | {error, any()}).
   publish(?QUEUE_TYPE_PER_OBJECT = Id, AddrId, Key, ErrorType) ->
  -    Clock = leo_date:clock(),
  -    KeyBin = term_to_binary({ErrorType, Key, Clock}),
  +    KeyBin = term_to_binary({ErrorType, Key}),
       MessageBin = term_to_binary(
  -                   #inconsistent_data_message{id        = Clock,
  -                                              type      = ErrorType,
  -                                              addr_id   = AddrId,
  -                                              key       = Key,
  +                   #inconsistent_data_message{id = leo_date:clock(),
  +                                              type = ErrorType,
  +                                              addr_id = AddrId,
  +                                              key = Key,
                                                 timestamp = leo_date:now()}),
       leo_mq_api:publish(queue_id(Id), KeyBin, MessageBin);
   
   publish(?QUEUE_TYPE_SYNC_OBJ_WITH_DC = Id, ClusterId, AddrId, Key) ->
  -    Clock = leo_date:clock(),
  -    KeyBin = term_to_binary({ClusterId, AddrId, Key, Clock}),
  +    KeyBin = term_to_binary({ClusterId, AddrId, Key}),
       MessageBin  = term_to_binary(
  -                    #inconsistent_data_with_dc{id         = Clock,
  +                    #inconsistent_data_with_dc{id = leo_date:clock(),
                                                  cluster_id = ClusterId,
  -                                               addr_id    = AddrId,
  -                                               key        = Key,
  -                                               del        = 0,
  -                                               timestamp  = leo_date:now()}),
  +                                               addr_id = AddrId,
  +                                               key = Key,
  +                                               del = 0,
  +                                               timestamp = leo_date:now()}),
       leo_mq_api:publish(queue_id(Id), KeyBin, MessageBin);
   
   publish(_,_,_,_) ->
  
positive.code:     leo_mq_api:publish(queue_id(Id), KeyBin, MessageBin);
  
  publish(?QUEUE_TYPE_SYNC_OBJ_WITH_DC = Id, ClusterId, AddrId, Key, Del) ->
      Clock = leo_date:clock(),
      KeyBin = term_to_binary({ClusterId, AddrId, Key, Clock}),
      MessageBin  = term_to_binary(
                      #inconsistent_data_with_dc{id         = Clock,
                                                 cluster_id = ClusterId,
                                                 addr_id    = AddrId,
                                                 key        = Key,
                                                 del        = Del,
                                                 timestamp  = leo_date:now()}),
      leo_mq_api:publish(queue_id(Id), KeyBin, MessageBin);
  
  publish(_,_,_,_,_) ->
  
negative.code: -spec(publish(queue_type(), atom()|binary()) ->
               ok | {error, any()}).
  publish(?QUEUE_TYPE_RECOVERY_NODE = Id, Node) ->
      KeyBin = term_to_binary(Node),
      MsgBin = term_to_binary(
                 #recovery_node_message{id = leo_date:clock(),
                                        node = Node,
                                        timestamp = leo_date:now()}),
      leo_mq_api:publish(queue_id(Id), KeyBin, MsgBin);
  publish(_,_) ->
  