Update infra_libs to 1.1.15 / 0b44aba87c1c6538439df6d24a409870810747ab

appengine/third_party/gae_ts_mon/config.py

 # Copyright 2015 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import copy
 import datetime
 import functools
 import logging
 import os
 import sys
@@ skipping 62 matching lines @@
     return False
   return _flush_metrics(time_now)
 
 
 def _flush_metrics(time_now):
   """Return True if metrics were actually sent."""
   if interface.state.target is None:
     # ts_mon is not configured.
     return False
 
-  logging.info('ts_mon: fetching TSMonInstance entity')
   datetime_now = datetime.datetime.utcfromtimestamp(time_now)
   entity = shared.get_instance_entity()
   if entity.task_num < 0:
     if interface.state.target.task_num >= 0:
       _reset_cumulative_metrics()
     interface.state.target.task_num = -1
     interface.state.last_flushed = entity.last_updated
     updated_sec_ago = (datetime_now - entity.last_updated).total_seconds()
     if updated_sec_ago > shared.INSTANCE_EXPECTED_TO_HAVE_TASK_NUM_SEC:
       logging.warning('Instance %s is %d seconds old with no task_num.',
                       shared.instance_key_id(), updated_sec_ago)
-    logging.info('ts_mon: skipping the flush, no task_num')
     return False
   interface.state.target.task_num = entity.task_num
 
-  logging.info('ts_mon: initiating TSMonInstance entity update')
   entity.last_updated = datetime_now
   entity_deferred = entity.put_async()
 
-  logging.info('ts_mon: doing the flush')
-  started = time.time()
   interface.flush()
-  logging.info(
-      'ts_mon: flush finished in %d ms', (time.time() - started) * 1000)
 
   for metric in interface.state.global_metrics.itervalues():
     metric.reset()
 
-  logging.info('ts_mon: waiting for TSMonInstance entity update to finish')
   entity_deferred.get_result()
-  logging.info('ts_mon: flush is done')
   return True
 
 
 def _shutdown_hook(time_fn=time.time):
   shared.shutdown_counter.increment()
   if flush_metrics_if_needed(time_fn()):
     logging.info('Shutdown hook: deleting %s, metrics were flushed.',
                  shared.instance_key_id())
   else:
     logging.warning('Shutdown hook: deleting %s, metrics were NOT flushed.',
@@ skipping 86 matching lines @@
 
   standard_metrics.init()
 
   logging.info('Initialized ts_mon with service_name=%s, job_name=%s, '
                'hostname=%s', service_name, job_name, hostname)
 
 
 def _instrumented_dispatcher(dispatcher, request, response, time_fn=time.time):
   start_time = time_fn()
   response_status = 0
-  interface.state.store.initialize_context()
   flush_thread = None
   time_now = time_fn()
   if need_to_flush_metrics(time_now):
-    logging.info('ts_mon: starting flush thread')
     flush_thread = threading.Thread(target=_flush_metrics, args=(time_now,))
     flush_thread.start()
   try:
     ret = dispatcher(request, response)
   except webapp2.HTTPException as ex:
     response_status = ex.code
     raise
   except Exception:
     response_status = 500
     raise
   else:
     if isinstance(ret, webapp2.Response):
       response = ret
     response_status = response.status_int
   finally:
     if flush_thread:
-      start_waiting = time_fn()
-      logging.info('ts_mon: joining flush thread')
       flush_thread.join()
-      logging.info(
-          'ts_mon: flush threads is done, waited %d ms',
-          (time_fn() - start_waiting) * 1000)
     elapsed_ms = int((time_fn() - start_time) * 1000)
 
     # Use the route template regex, not the request path, to prevent an
     # explosion in possible field values.
     name = request.route.template if request.route is not None else ''
 
     http_metrics.update_http_server_metrics(
         name, response_status, elapsed_ms,
         request_size=request.content_length,
         response_size=response.content_length,
@@ skipping 21 matching lines @@
   """Decorator to instrument Cloud Endpoint methods."""
   def decorator(fn):
     method_name = fn.__name__
     assert method_name
     @functools.wraps(fn)
     def decorated(service, *args, **kwargs):
       service_name = service.__class__.__name__
       endpoint_name = '/_ah/spi/%s.%s' % (service_name, method_name)
       start_time = time_fn()
       response_status = 0
-      interface.state.store.initialize_context()
       flush_thread = None
       time_now = time_fn()
       if need_to_flush_metrics(time_now):
         flush_thread = threading.Thread(target=_flush_metrics, args=(time_now,))
         flush_thread.start()
       try:
         ret = fn(service, *args, **kwargs)
         response_status = 200
         return ret
       except endpoints.ServiceException as e:
@@ skipping 22 matching lines @@
     if hasattr(fn, 'im_class') and hasattr(fn, 'im_func'):  # Bound method.
       return '.'.join([
           fn.im_class.__module__,
           fn.im_class.__name__,
           fn.im_func.func_name])
     if hasattr(fn, '__name__'):  # Function.
       return fn.__module__ + '.' + fn.__name__
     return '<unknown>'  # pragma: no cover
 
   def process_view(self, request, view_func, view_args, view_kwargs):
-    interface.state.store.initialize_context()
-
     time_now = self._time_fn()
     state = {
         'flush_thread': None,
         'name': self._callable_name(view_func),
         'start_time': time_now,
     }
 
     if need_to_flush_metrics(time_now):
       thread = threading.Thread(target=_flush_metrics, args=(time_now,))
       thread.start()
@@ skipping 26 matching lines @@
         response.status_code,
         duration_secs * 1000,
         request_size=request_size,
         response_size=response_size,
         user_agent=request.META.get('HTTP_USER_AGENT', None))
     return response
 
 
 def reset_for_unittest(disable=False):
   interface.reset_for_unittest(disable=disable)