def send(self):
        """
        Entrypoint to send data to Zabbix
        If debug is enabled, items are sent one by one
        If debug isn't enable, we send items in bulk
        Returns a list of results (1 if no debug, as many as items in other case)
        """
        if self.logger: # pragma: no cover
            self.logger.info("Starting to send %d items" % len(self._items_list))
        try:
            # Zabbix trapper send a maximum of 250 items in bulk
            # We have to respect that, in case of enforcement on zabbix server side
            # Special case if debug is enabled: we need to send items one by one
            max_value = ZBX_TRAPPER_MAX_VALUE
            if self.debug_level >= 4:
                max_value = 1
                if self.logger: # pragma: no cover
                    self.logger.debug("Bulk limit is %d items" % max_value)
            else:
                if self.logger: # pragma: no cover
                    self.logger.info("Bulk limit is %d items" % max_value)
            # Initialize offsets & counters
            max_offset = len(self._items_list)
            run = 0
            start_offset = 0
            stop_offset = min(start_offset + max_value, max_offset)
            server_success = server_failure = processed = failed = total = time = 0
            while start_offset < stop_offset:
                run += 1
                if self.logger: # pragma: no cover
                    self.logger.debug(
                        'run %d: start_offset is %d, stop_offset is %d' %
                        (run, start_offset, stop_offset)
                    )

                # Extract items to be send from global item's list'
                _items_to_send = self.items_list[start_offset:stop_offset]

                # Send extracted items
                run_response, run_processed, run_failed, run_total, run_time = self._send_common(_items_to_send)

                # Update counters
                if run_response == 'success':
                    server_success += 1
                elif run_response == 'failed':
                    server_failure += 1
                processed += run_processed
                failed += run_failed
                total += run_total
                time += run_time
                if self.logger: # pragma: no cover
                    self.logger.info("%d items sent during run %d" % (run_total, run))
                    self.logger.debug(
                        'run %d: processed is %d, failed is %d, total is %d' %
                        (run, run_processed, run_failed, run_total)
                    )

                # Compute next run's offsets
                start_offset = stop_offset
                stop_offset = min(start_offset + max_value, max_offset)

                # Reset socket, which is likely to be closed by server
                self._socket_reset()
        except:
            self._reset()
            self._socket_reset()
            raise
        if self.logger: # pragma: no cover
            self.logger.info('All %d items have been sent in %d runs' % (total, run))
            self.logger.debug(
                'Total run is %d; item processed: %d, failed: %d, total: %d, during %f seconds' %
                (run, processed, failed, total, time)
            )
        # Everything has been sent.
        # Reset DataContainer & return results_list
        self._reset()
        return server_success, server_failure, processed, failed, total, time