code: def report(self, req):
          
          if self._cache is None:
              return None  # no cache, send request now
          if not isinstance(req, sc_messages.ServicecontrolServicesReportRequest):
              raise ValueError(u'Invalid request')
          if req.serviceName != self.service_name:
              _logger.error(u'bad report(): service_name %s does not match ours %s',
                            req.serviceName, self.service_name)
              raise ValueError(u'Service name mismatch')
          report_req = req.reportRequest
          if report_req is None:
              _logger.error(u'bad report(): no report_request in %s', req)
              raise ValueError(u'Expected report_request not set')
          if _has_high_important_operation(report_req) or self._cache is None:
              return None
          ops_by_signature = _key_by_signature(report_req.operations,
                                               _sign_operation)
  
          # Concurrency:
          #
          # This holds a lock on the cache while updating it.  No i/o operations
          # are performed, so any waiting threads see minimal delays
          with self._cache as cache:
              for key, op in ops_by_signature.items():
                  agg = cache.get(key)
                  if agg is None:
                      cache[key] = operation.Aggregator(op, self._kinds)
                  else:
                      agg.add(op)
  
          return self.CACHED_OK
docs: Adds a report request to the cache.
  
          Returns ``None`` if it could not be aggregated, and callers need to
          send the request to the server, otherwise it returns ``CACHED_OK``.
  
          Args:
             req (:class:`sc_messages.ReportRequest`): the request
               to be aggregated
  
          Result:
             ``None`` if the request as not cached, otherwise ``CACHED_OK``