def create_app():
app = Flask(__name__)
agent = Agent()
agent.instrument(app)
@app.route('/', methods=['POST'])
def hello():
request_data = request.get_json()
name = request_data['name']
user_id = insert_user(name)
res_body = {'id': user_id, 'message': f'Hello {name}'}
stream = request.args.get('stream')
if stream == 'true':
# Send the response as stream
return Response(stream_body(json.dumps(res_body)),
mimetype='application/json')
else:
# Send the entire response
response = make_response(jsonify(res_body))
response.headers['Content-Type'] = 'application/json'
return response
return app
def test_run():
logger = setup_custom_logger(__name__)
os.environ['_HANDLER'] = 'test_lambda.example_lambda'
agent = Agent()
agent.instrument(None)
memory_exporter = configure_inmemory_span_exporter(agent)
logger.info('Running test calls.')
lamb = boto.awslambda.connect_to_region("us-east-2")
# multiple calls
try:
lamb.list_functions()
except:
pass
spans = memory_exporter.get_finished_spans()
assert spans
assert len(spans) == 1
span = spans[0]
assert span.attributes['endpoint'] == 'lambda'
assert span.attributes['http.method'] == 'GET'
assert span.attributes['aws.region'] == 'us-east-2'
assert span.attributes['aws.operation'] == 'list_functions'
memory_exporter.clear()
def agent():
# we never want to export spans to default exporter
os.environ['HT_ENABLE_CONSOLE_SPAN_EXPORTER'] = 'true'
# new patches will just replace old ones which allows us to call `agent.instrument()` during each test
_uninstrument_all()
Agent._instance = None
agent = Agent()
return agent
def test_run():
logger = setup_custom_logger(__name__)
agent = Agent()
agent.instrument(None)
# Setup In-Memory Span Exporter
logger.info('Agent initialized.')
logger.info('Adding in-memory span exporter.')
memoryExporter = InMemorySpanExporter()
simpleExportSpanProcessor = SimpleSpanProcessor(memoryExporter)
agent.register_processor(simpleExportSpanProcessor)
logger.info('Added in-memory span exporter')
logger.info('Running test calls.')
try:
session = botocore.session.get_session()
session.set_credentials(access_key="access-key",
secret_key="secret-key")
region = "us-west-2"
client = session.create_client("lambda", region_name=region)
iam_client = session.create_client("iam", region_name=region)
arn = _create_role_and_get_arn(iam_client)
result = _create_lambda_function('some_function',
return_headers_lambda_str(), client,
arn)
memoryExporter.clear()
response = client.invoke(
Payload=json.dumps({}),
FunctionName=result['FunctionArn'],
InvocationType="RequestResponse",
)
spans = memoryExporter.get_finished_spans()
invoke_span = spans[-1]
assert invoke_span.attributes['faas.invoked_name'] == 'some_function'
assert invoke_span.attributes['http.status_code'] == 200
assert invoke_span.attributes['rpc.service'] == 'Lambda'
memoryExporter.clear()
return 0
except:
logger.error(
'Failed to test boto instrumentation wrapper: exception=%s, stacktrace=%s',
sys.exc_info()[0], traceback.format_exc())
raise sys.exc_info()[0]
import aiohttp
import asyncio
from hypertrace.agent import Agent
import os
import json
import logging
agent = Agent()
agent.instrument()
logging.basicConfig()
logging.getLogger().setLevel(logging.DEBUG)
async def main():
async with aiohttp.ClientSession() as session:
isStream = False
if 'STREAM' in os.environ and os.environ['STREAM'] == 'true':
isStream = True
query = ""
if isStream:
logging.debug('Receving response stream')
query = "?stream=true"
async with session.post(
'http://localhost:9000/' + query,
data='{"name":"Dave"}',
headers={'content-type': 'application/json'}
) as resp:
if isStream:
assert sql1SpanAsObject['attributes'][
'db.statement'] == "INSERT INTO hypertrace_data (col1, col2) VALUES (123, 'abcdefghijklmnopqrstuvwxyz')"
memoryExporter.clear()
return response
except:
logger.error(
'An error occurred validating span data: exception=%s, stacktrace=%s',
sys.exc_info()[0], traceback.format_exc())
raise sys.exc_info()[0]
agent = None
if ENABLE_INSTRUMENTATION == True:
#
# Code snippet here represents the current initialization logic
#
logger.info('Initializing agent.')
agent = Agent()
agent.instrument(server)
#
# End initialization logic for Python Agent
#
# Setup In-Memory Span Exporter
logger.info('Agent initialized.')
logger.info('Adding in-memory span exporter.')
memoryExporter = InMemorySpanExporter()
simpleExportSpanProcessor = SimpleSpanProcessor(memoryExporter)
agent.register_processor(simpleExportSpanProcessor)
logger.info('Added in-memoy span exporter')
def post_fork(server, worker):
"""Used to reinitialize exporter & processors in separate worker processes"""
from hypertrace.agent import Agent # pylint:disable=C0411,C0415
server.log.info("Add post hook %s", worker.pid)
Agent()._init.post_fork() # pylint:disable=W0212
import os
from importlib import import_module
from hypertrace.agent import Agent
def modify_module_name(module_name):
"""Returns a valid modified module to get imported"""
return ".".join(module_name.split("/"))
class HandlerError(Exception):
pass
a = Agent()
a.instrument(None, auto_instrument=True)
path = os.environ.get("ORIG_HANDLER")
if path is None:
raise HandlerError("ORIG_HANDLER is not defined.")
try:
(mod_name, handler_name) = path.rsplit(".", 1)
except ValueError as e:
raise HandlerError("Bad path '{}' for ORIG_HANDLER: {}".format(path, str(e)))
modified_mod_name = modify_module_name(mod_name)
handler_module = import_module(modified_mod_name)
"""
WSGI config for testapp project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.2/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
from hypertrace.agent import Agent
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'tests.hypertrace.agent.instrumentation.django.testapp.settings')
TEST_AGENT_INSTANCE = Agent()
TEST_AGENT_INSTANCE.instrument()
application = get_wsgi_application()
'''Enable instrumentationon all supported modules.''' # pylint: disable=R0401
import logging
from hypertrace.agent import Agent
from hypertrace.env_var_settings import get_env_value
# Initialize logger
logger = logging.getLogger(__name__) # pylint: disable=C0103
skip_modules = get_env_value('SKIP_MODULES')
if skip_modules:
logger.debug("[env] Loaded SKIP_MODULES from env")
if len(skip_modules) > 0:
skip_modules = skip_modules.replace(' ', '')
skip_modules = skip_modules.split(',')
else:
skip_modules = []
# Create Hypertrace agent
agent = Agent()
agent.instrument(None, skip_modules, auto_instrument=True)