def post_handle(self):
""" An internal method executed after the service has completed and has
a response ready to return. Updates its statistics and, optionally, stores
a sample request/response pair.
"""
#
# Statistics
#
self.handle_return_time = datetime.utcnow()
self.processing_time_raw = self.handle_return_time - self.invocation_time
self.processing_time = int(round(self.processing_time_raw.microseconds / 1000.0))
self.kvdb.conn.hset('{}{}'.format(KVDB.SERVICE_TIME_BASIC, self.name), 'last', self.processing_time)
self.kvdb.conn.rpush('{}{}'.format(KVDB.SERVICE_TIME_RAW, self.name), self.processing_time)
key = '{}{}:{}'.format(KVDB.SERVICE_TIME_RAW_BY_MINUTE,
self.name, self.handle_return_time.strftime('%Y:%m:%d:%H:%M'))
self.kvdb.conn.rpush(key, self.processing_time)
# .. we'll have 5 minutes (5 * 60 seconds = 300 seconds)
# to aggregate processing times for a given minute and then it will expire
# TODO: Document that we need Redis 2.1.3+ otherwise the key has just been overwritten
self.kvdb.conn.expire(key, 300)
#
# Sample requests/responses
#
key, freq = request_response.should_store(self.kvdb, self.usage, self.name)
if freq:
data = {
'cid': self.cid,
'req_ts': self.invocation_time.isoformat(),
'resp_ts': self.handle_return_time.isoformat(),
'req': self.request.raw_request or '',
'resp': self.response.payload or '',
}
request_response.store(self.kvdb, key, self.usage, freq, **data)
#
# Slow responses
#
if self.processing_time > self.slow_threshold:
data = {
'cid': self.cid,
'proc_time': self.processing_time,
'slow_threshold': self.slow_threshold,
'req_ts': self.invocation_time.isoformat(),
'resp_ts': self.handle_return_time.isoformat(),
'req': self.request.raw_request or '',
'resp': self.response.payload or '',
}
slow_response.store(self.kvdb, self.name, **data)
def post_handle(self):
""" An internal method executed after the service has completed and has
a response ready to return. Updates its statistics and, optionally, stores
a sample request/response pair.
"""
#
# Statistics
#
self.handle_return_time = datetime.utcnow()
self.processing_time_raw = self.handle_return_time - self.invocation_time
if self.server.component_enabled.stats:
proc_time = self.processing_time_raw.total_seconds() * 1000.0
proc_time = proc_time if proc_time > 1 else 0
self.processing_time = int(round(proc_time))
with self.kvdb.conn.pipeline() as pipe:
pipe.hset('{}{}'.format(KVDB.SERVICE_TIME_BASIC, self.name), 'last', self.processing_time)
pipe.rpush('{}{}'.format(KVDB.SERVICE_TIME_RAW, self.name), self.processing_time)
key = '{}{}:{}'.format(KVDB.SERVICE_TIME_RAW_BY_MINUTE,
self.name, self.handle_return_time.strftime('%Y:%m:%d:%H:%M'))
pipe.rpush(key, self.processing_time)
# .. we'll have 5 minutes (5 * 60 seconds = 300 seconds)
# to aggregate processing times for a given minute and then it will expire
# Note that we need Redis 2.1.3+ otherwise the key has just been overwritten
pipe.expire(key, 300)
pipe.execute()
#
# Sample requests/responses
#
key, freq = request_response.should_store(self.kvdb, self.usage, self.name)
if freq:
# TODO: Don't parse it here and a moment later below
resp = (self.response.payload.getvalue() if hasattr(self.response.payload, 'getvalue') else self.response.payload) or ''
data = {
'cid': self.cid,
'req_ts': self.invocation_time.isoformat(),
'resp_ts': self.handle_return_time.isoformat(),
'req': self.request.raw_request or '',
'resp':resp,
}
request_response.store(self.kvdb, key, self.usage, freq, **data)
#
# Slow responses
#
if self.server.component_enabled.slow_response:
if self.processing_time > self.slow_threshold:
# TODO: Don't parse it here and a moment earlier above
resp = (self.response.payload.getvalue() if hasattr(self.response.payload, 'getvalue')
else self.response.payload) or ''
data = {
'cid': self.cid,
'proc_time': self.processing_time,
'slow_threshold': self.slow_threshold,
'req_ts': self.invocation_time.isoformat(),
'resp_ts': self.handle_return_time.isoformat(),
'req': self.request.raw_request or '',
'resp': resp,
}
slow_response.store(self.kvdb, self.name, **data)
def post_handle(
self,
_get_response_value=get_response_value,
_utcnow=datetime.utcnow,
_service_time_basic=KVDB.SERVICE_TIME_BASIC,
_service_time_raw=KVDB.SERVICE_TIME_RAW,
_service_time_raw_by_minute=KVDB.SERVICE_TIME_RAW_BY_MINUTE):
""" An internal method executed after the service has completed and has
a response ready to return. Updates its statistics and, optionally, stores
a sample request/response pair.
"""
#
# Statistics
#
self.handle_return_time = _utcnow()
self.processing_time_raw = self.handle_return_time - self.invocation_time
if self.server.component_enabled.stats:
proc_time = self.processing_time_raw.total_seconds() * 1000.0
proc_time = proc_time if proc_time > 1 else 0
self.processing_time = int(round(proc_time))
with self.kvdb.conn.pipeline() as pipe:
pipe.hset('%s%s' % (_service_time_basic, self.name), 'last',
self.processing_time)
pipe.rpush('%s%s' % (_service_time_raw, self.name),
self.processing_time)
key = '%s%s:%s' % (
_service_time_raw_by_minute, self.name,
self.handle_return_time.strftime('%Y:%m:%d:%H:%M'))
pipe.rpush(key, self.processing_time)
# .. we'll have 5 minutes (5 * 60 seconds = 300 seconds)
# to aggregate processing times for a given minute and then it will expire
# Note that we need Redis 2.1.3+ otherwise the key has just been overwritten
pipe.expire(key, 300)
pipe.execute()
#
# Sample requests/responses
#
if self._req_resp_freq and self.usage % self._req_resp_freq == 0:
data = {
'cid': self.cid,
'req_ts': self.invocation_time.isoformat(),
'resp_ts': self.handle_return_time.isoformat(),
'req': self.request.raw_request or '',
'resp': _get_response_value(
self.response
), # TODO: Don't parse it here and a moment later below
}
self.kvdb.conn.hmset(key, data)
#
# Slow responses
#
if self.server.component_enabled.slow_response:
if self.processing_time > self.slow_threshold:
data = {
'cid': self.cid,
'proc_time': self.processing_time,
'slow_threshold': self.slow_threshold,
'req_ts': self.invocation_time.isoformat(),
'resp_ts': self.handle_return_time.isoformat(),
'req': self.request.raw_request or '',
'resp': _get_response_value(
self.response
), # TODO: Don't parse it here and a moment earlier above
}
slow_response.store(self.kvdb, self.name, **data)
def post_handle(self):
""" An internal method executed after the service has completed and has
a response ready to return. Updates its statistics and, optionally, stores
a sample request/response pair.
"""
#
# Statistics
#
self.handle_return_time = datetime.utcnow()
self.processing_time_raw = self.handle_return_time - self.invocation_time
if self.server.component_enabled.stats:
proc_time = self.processing_time_raw.total_seconds() * 1000.0
proc_time = proc_time if proc_time > 1 else 0
self.processing_time = int(round(proc_time))
with self.kvdb.conn.pipeline() as pipe:
pipe.hset('{}{}'.format(KVDB.SERVICE_TIME_BASIC, self.name), 'last', self.processing_time)
pipe.rpush('{}{}'.format(KVDB.SERVICE_TIME_RAW, self.name), self.processing_time)
key = '{}{}:{}'.format(KVDB.SERVICE_TIME_RAW_BY_MINUTE,
self.name, self.handle_return_time.strftime('%Y:%m:%d:%H:%M'))
pipe.rpush(key, self.processing_time)
# .. we'll have 5 minutes (5 * 60 seconds = 300 seconds)
# to aggregate processing times for a given minute and then it will expire
# Note that we need Redis 2.1.3+ otherwise the key has just been overwritten
pipe.expire(key, 300)
pipe.execute()
#
# Sample requests/responses
#
key, freq = request_response.should_store(self.kvdb, self.usage, self.name)
if freq:
# TODO: Don't parse it here and a moment later below
resp = (self.response.payload.getvalue() if hasattr(self.response.payload, 'getvalue') else self.response.payload) or ''
data = {
'cid': self.cid,
'req_ts': self.invocation_time.isoformat(),
'resp_ts': self.handle_return_time.isoformat(),
'req': self.request.raw_request or '',
'resp':resp,
}
request_response.store(self.kvdb, key, self.usage, freq, **data)
#
# Slow responses
#
if self.server.component_enabled.slow_response:
if self.processing_time > self.slow_threshold:
# TODO: Don't parse it here and a moment earlier above
resp = (self.response.payload.getvalue() if hasattr(self.response.payload, 'getvalue') \
else self.response.payload) or ''
data = {
'cid': self.cid,
'proc_time': self.processing_time,
'slow_threshold': self.slow_threshold,
'req_ts': self.invocation_time.isoformat(),
'resp_ts': self.handle_return_time.isoformat(),
'req': self.request.raw_request or '',
'resp': resp,
}
slow_response.store(self.kvdb, self.name, **data)
