code: def _write_measurements():
      
      global _timeout, _writing
  
      future = concurrent.Future()
  
      if _writing:
          LOGGER.warning('Currently writing measurements, skipping write')
          future.set_result(False)
      elif not _pending_measurements():
          future.set_result(True)
      elif not _sample_batch():
          LOGGER.debug('Skipping batch submission due to sampling')
          future.set_result(True)
  
      # Exit early if there's an error condition
      if future.done():
          return future
  
      if not _http_client or _dirty:
          _create_http_client()
  
      # Keep track of the futures for each batch submission
      futures = []
  
      # Submit a batch for each database
      for database in _measurements:
          url = '{}?db={}&precision=ms'.format(_base_url, database)
  
          # Get the measurements to submit
          measurements = _measurements[database][:_max_batch_size]
  
          # Pop them off the stack of pending measurements
          _measurements[database] = _measurements[database][_max_batch_size:]
  
          # Create the request future
          LOGGER.debug('Submitting %r measurements to %r',
                       len(measurements), url)
          request = _http_client.fetch(
              url, method='POST', body='\n'.join(measurements).encode('utf-8'))
  
          # Keep track of each request in our future stack
          futures.append((request, str(uuid.uuid4()), database, measurements))
  
      # Start the wait cycle for all the requests to complete
      _writing = True
      _futures_wait(future, futures)
  
      return future
docs: Write out all of the metrics in each of the databases,
      returning a future that will indicate all metrics have been written
      when that future is done.
  
      :rtype: tornado.concurrent.Future