def handle_msg(self,
                   body,
                   org_message):
        """handle_msg

        :param body: dictionary contents from the message body
        :param org_message: message object can ack, requeue or reject
        """

        if os.path.exists(self.stop_for_file):
            log.info(("Detected stop_file={} "
                      "shutting down")
                     .format(self.stop_for_file))

            # drop the message back in the queue
            # for next time
            org_message.requeue()

            sys.exit(1)
        # end of stop file detection

        try:

            log.debug(("handle body={}")
                      .format(ppj(body)))

            msg = body
            id = build_packet_key()
            recv_time = rnow()

            # this could be made into celery tasks...

            flat_msg = self.build_flat_msg(
                            id=id,
                            msg=msg)

            if not flat_msg:
                log.error(("Failed to build a flat message "
                           "for message={}")
                          .format(msg))
                return

            msg["id"] = id
            msg["received"] = recv_time
            if len(flat_msg) > 0:
                if self.debug:
                    log.info(ppj(flat_msg))
                flat_msg["id"] = id
                flat_msg["received"] = recv_time
                self.all_flat.append(flat_msg)
                self.recv_msgs.append(msg)
            # end of adding all flat messages

            already_saved = False
            num_recv = len(self.recv_msgs)
            if (num_recv % self.save_after_num) == 0:
                already_saved = False
                self.save_data()
            # end of saving a snapshot

            if self.stop_after_num:
                if num_recv >= self.stop_after_num:
                    if not already_saved:
                        self.save_data()
                    # avoid waiting on the save again
                    log.info("archive successful - purging buffer")
                    sys.exit(2)
                # shutdown - good for testing
            # if now set up for infinite consuming

        except Exception as e:
            log.error(("Failed processing msg={} "
                       "ex={}")
                      .format(body,
                              e))
        # end of processing message

        try:
            org_message.ack()
        except Exception as e:
            log.error(("Failed ack-ing msg={} "
                       "ex={}")
                      .format(body,
                              e))
        # end of acknowleding message was processed

        log.info("done handle")
handle_msg

        :param body: dictionary contents from the message body
        :param org_message: message object can ack, requeue or reject