pax_global_header00006660000000000000000000000064140036554020014511gustar00rootroot0000000000000052 comment=1cde344bc7132576eb807a83b938d8dc778a9870 haystack-client-python-0.2.2/000077500000000000000000000000001400365540200161145ustar00rootroot00000000000000haystack-client-python-0.2.2/.gitignore000066400000000000000000000022731400365540200201100ustar00rootroot00000000000000# Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions *.so # Distribution / packaging .Python build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ wheels/ *.egg-info/ .installed.cfg *.egg MANIFEST # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *.cover .hypothesis/ .pytest_cache/ # Translations *.mo *.pot # Django stuff: *.log local_settings.py db.sqlite3 # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs/_build/ # PyBuilder target/ # Jupyter Notebook .ipynb_checkpoints # pyenv .python-version # celery beat schedule file celerybeat-schedule # SageMath parsed files *.sage.py # Environments .env .venv env/ venv/ ENV/ env.bak/ venv.bak/ # Spyder project settings .spyderproject .spyproject # Rope project settings .ropeproject .idea/ # mkdocs documentation /site # mypy .mypy_cache/ haystack-client-python-0.2.2/.gitmodules000066400000000000000000000001511400365540200202660ustar00rootroot00000000000000[submodule "haystack-idl"] path = haystack-idl url = https://github.com/ExpediaDotCom/haystack-idl.git haystack-client-python-0.2.2/.travis.yml000066400000000000000000000005711400365540200202300ustar00rootroot00000000000000sudo: required dist: trusty language: python python: 3.6 services: - docker install: make bootstrap script: make lint test integration_tests before_deploy: - git stash --all - make set_version deploy: provider: pypi user: $PYPI_USERNAME password: $PYPI_PASSWORD distributions: "sdist bdist_wheel" skip_cleanup: true on: branch: master tags: true haystack-client-python-0.2.2/CHANGELOG.md000066400000000000000000000001361400365540200177250ustar00rootroot00000000000000# Changes by Version ## 1.0.0 (2019-02-25) Haystack OpenTracing compliant library for Python haystack-client-python-0.2.2/LICENSE000066400000000000000000000261171400365540200171300ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright 2019 Expedia, Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. haystack-client-python-0.2.2/Makefile000066400000000000000000000024001400365540200175500ustar00rootroot00000000000000.PHONY: build build: echo "nothing to compile" .PHONY: bootstrap bootstrap: python setup.py install .PHONY: test test: python setup.py test .PHONY: example example: bootstrap python examples/main.py .PHONY: lint lint: pip install flake8 python -m flake8 ./haystack --exclude *_pb2* && echo "Flake8 passed without any issues!" .PHONY: integration_tests integration_tests: docker-compose -f tests/integration/docker-compose.yml -p sandbox up -d echo "sleeping for 15s while kafka/zookeeper initialize" sleep 15 docker run -it \ --rm \ --network=sandbox_default \ -v $(PWD):/ws \ -w /ws \ python:3.6 \ /bin/sh -c 'python setup.py install && pip install kafka-python && python tests/integration/integration.py' docker-compose -f tests/integration/docker-compose.yml -p sandbox stop .PHONY: set_version set_version: pip install semver pip install requests python ./scripts/version.py .PHONY: proto_compile proto_compile: git submodule init -- ./haystack-idl git submodule update pip install grpcio-tools python -m grpc_tools.protoc -I haystack-idl/ --python_out=./haystack haystack-idl/proto/span.proto python -m grpc_tools.protoc -I haystack-idl/proto --python_out=./haystack/proto --grpc_python_out=./haystack/proto agent/spanAgent.proto haystack-client-python-0.2.2/README.md000066400000000000000000000054471400365540200174050ustar00rootroot00000000000000[![Build Status](https://travis-ci.org/ExpediaDotCom/haystack-client-python.svg?branch=master)](https://travis-ci.org/ExpediaDotCom/haystack-client-python) [![License](https://img.shields.io/badge/license-Apache%20License%202.0-blue.svg)](https://github.com/ExpediaDotCom/haystack/blob/master/LICENSE) # Haystack bindings for Python OpenTracing API This is Haystack's client library for Python that implements [OpenTracing](https://github.com/opentracing/opentracing-python/) Further information can be found on [opentracing.io](https://opentracing.io/) ## Using this library See examples in /examples directory. See opentracing [usage](https://github.com/opentracing/opentracing-python/#usage) for additional information. It is important to consider the architecture of the application. In order for the tracer to manage spans properly, an appropriate `ScopeManager` implementation must be chosen. In most environments, the default `ThreadLocalScopeManager` will work just fine. In asynchronous frameworks, the `ContextVarsScopeManager` is a better choice. First initialize the tracer at the application level by supplying a service name and span recorder ```python import opentracing from haystack import HaystackAgentRecorder from haystack import HaystackTracer tracer = HaystackTracer("a_service", HaystackAgentRecorder()) opentracing.set_global_tracer(tracer) ``` Starting a span can be done as a managed resource using `start_active_span()` ```python with opentracing.tracer.start_active_span("span-name") as scope: do_stuff() ``` or finish the span on your own terms with ```python span = opentracing.tracer.start_span("span-name") do_stuff() span.finish() ``` Note: **If there is a Scope, it will act as the parent to any newly started Span** unless the programmer passes `ignore_active_span=True` at `start_span()/start_active_span()` time or specified parent context explicitly using `childOf=parent_context` #### Custom propagation headers If necessary, default propagation headers can be replaced with custom ones by specifying custom propagator options. Register the new propagator with the tracer once configured. ```python prop_opts = PropagatorOpts("X-Trace-ID", "X-Span-ID", "X-Parent-Span", "X-baggage-") opentracing.tracer.register_propagator(opentracing.Format.HTTP_HEADERS, TextPropagator(prop_opts)) ``` #### Logging All modules define their logger via `logging.getLogger(__name__)` So in order to define specific logging format or level for this library use `getLogger('haystack')` or configure the root logger. ## How to configure build environment Create a python3 virtual environment, activate it and then `make bootstrap` ## Running the example code `make example` ## How to Release this library Create a new release in github specifying a semver compliant tag greater than the current release version.haystack-client-python-0.2.2/examples/000077500000000000000000000000001400365540200177325ustar00rootroot00000000000000haystack-client-python-0.2.2/examples/main.py000066400000000000000000000125171400365540200212360ustar00rootroot00000000000000import opentracing import logging import time from opentracing import tags from haystack import HaystackTracer from haystack import LoggerRecorder def setup_tracer(): global recorder recorder = LoggerRecorder() # instantiate a haystack tracer for this service and set a common tag which applies to all traces tracer = HaystackTracer("Service-A", recorder, common_tags={"app.version": "1234"}) # now set the global tracer, so we can reference it with opentracing.tracer anywhere in our app opentracing.set_global_tracer(tracer) def handle_request(request_body): logging.info(f"handling new request - {request_body}") # this next line does a few things.. namely, it starts a new scope (which contains the span) to represent # the scope of this "work". In this case, it should represent the work involved in processing the entire request with opentracing.tracer.start_active_span("a_controller_method") as parent_scope: # once within the context of an active span, there are three different ways to assign additional info or # or attributes to the span """ First we'll add some tags to the span Tags are key:value pairs that enable user-defined annotation of spans in order to query, filter, and comprehend trace data Tags have semantic conventions, see https://opentracing.io/specification/conventions/ *tags do NOT propagate to child spans """ parent_scope.span.set_tag(tags.HTTP_URL, "http://localhost/mocksvc") parent_scope.span.set_tag(tags.HTTP_METHOD, "GET") parent_scope.span.set_tag(tags.SPAN_KIND, "server") """ Next we'll add some baggage to the span. Baggage carries data across process boundaries.. aka it DOES propagate to child spans """ parent_scope.span.set_baggage_item("business_id", "1234") """ Next lets assume you need to authenticate the client making the request """ with opentracing.tracer.start_active_span("authenticate"): time.sleep(.25) # fake doing some authentication work.. """ Finally, we'll add a log event to the request level span. Logs are key:value pairs that are useful for capturing timed log messages and other debugging or informational output from the application itself. Logs may be useful for documenting a specific moment or event within the span (in contrast to tags which should apply to the span regardless of time). """ parent_scope.span.log_kv( { "some_string_value": "foobar", "an_int_value": 42, "a_float_value": 4.2, "a_bool_value": True, "an_obj_as_value": { "ok": "hmm", "blah": 4324 } }) try: """ Now lets say that as part of processing this request, we need to invoke some downstream service """ make_a_downstream_request() except Exception: # if that fails, we'll tag the request-scoped span with an error so we have success/fail metrics in haystack parent_scope.span.set_tag(tags.ERROR, True) def act_as_remote_service(headers): # remote service would have it"s own tracer with HaystackTracer("Service-B", recorder) as tracer: # simulate network transfer delay time.sleep(.25) # now as-if this was executing on the remote service, extract the parent span ctx from headers upstream_span_ctx = tracer.extract(opentracing.Format.HTTP_HEADERS, headers) with tracer.start_active_span("controller_method", child_of=upstream_span_ctx) as parent_scope: parent_scope.span.set_tag(tags.SPAN_KIND, "server") # simulate downstream service doing some work before replying time.sleep(1) def make_a_downstream_request(): # create a child span representing the downstream request from current span. # Behind the scenes this uses the scope_manger to access the current active # span (which would be our request-scoped span called "a_controller_method" and create a child of it. with opentracing.tracer.start_active_span("downstream_req") as child_scope: child_scope.span.set_tag(tags.SPAN_KIND, "client") # In order for the downstream client to use this trace as a parent, we must propagate the current span context. # This is done by calling .inject() on the tracer headers = {} opentracing.tracer.inject(child_scope.span.context, opentracing.Format.HTTP_HEADERS, headers) act_as_remote_service(headers) # process the response from downstream time.sleep(.15) def main(): """ This function represents a "parent" application/service.. i.e. the originating service of our traces in this example. In this scenario, we're pretending to be a web server. """ # at some point during application init, you'll want to instantiate the global tracer setup_tracer() # here we assume the web framework invokes this method to handle the given request handle_request("hello world") # app shutdown logging.info("done") if __name__ == "__main__": logging.basicConfig(level=logging.DEBUG) main() haystack-client-python-0.2.2/examples/serverless/000077500000000000000000000000001400365540200221275ustar00rootroot00000000000000haystack-client-python-0.2.2/examples/serverless/handler.py000066400000000000000000000067521400365540200241300ustar00rootroot00000000000000# AWS Lambda Example import opentracing import os from requests import RequestException from opentracing import tags from haystack import HaystackTracer from haystack import SyncHttpRecorder """ Note: Recorder implementation in serverless applications requires careful consideration. For Example, in AWS, due to the way AWS lambda freezes execution context, it's not reliable to send requests via the AsyncHttpRecorder. If the function is not time-sensitive in reply or is async, SyncHttpRecorder is a good fit as shown below. If the function cannot afford to dispatch the span in-process, then it is recommended to either setup a haystack agent in the network and utilize HaystackAgentRecorder or offload the span record dispatching via Queue -> Worker model. In AWS this could mean implementing a SQSRecorder which puts the finished span onto a SQS queue. The queue could then notify a lambda implementing SyncHttpRecorder to dispatch the records. """ recorder = SyncHttpRecorder(os.env["COLLECTOR_URL"]) # suppose it is desired to tag all traces with the application version common_tags = { "svc_ver": os["APP_VERSION"] } tracer = HaystackTracer("example-service", recorder, common_tags=common_tags) opentracing.set_global_tracer(tracer) def invoke_downstream(headers): return "done" def process_downstream_response(response): return "done" def handler(event, context): # extract the span context from headers if this is a downstream service parent_ctx = opentracing.tracer.extract(opentracing.Format.HTTP_HEADERS, event) # now create a span representing the work of this entire function with opentracing.tracer.start_active_span("example-operation", child_of=parent_ctx) as request_scope: # log any important tags/baggage to the handler's span span = request_scope.span span.set_tag(tags.HTTP_URL, event["url"]) span.set_tag(tags.SPAN_KIND, "server") # do some work (for ex. validation) # then log an event to the span which will timestamp the time taken up until this point span.log_kv({"validation_result": "success"}) # an example of invoking a downstream service # Behind the scenes this uses the scope_manger to access the current active span and create a child of it. with opentracing.tracer.start_active_span("example-downstream-call") as child_scope: # span kind tags help haystack stitch and merge spans child_scope.span.set_tag(tags.SPAN_KIND, "client") headers = { "Content-Type": "application/json" } # inject the child span into the headers of downstream request opentracing.tracer.inject(child_scope.span.context, opentracing.Format.HTTP_HEADERS, headers) try: span.set_tag(tags.HTTP_URL, "https://downstream.url") response = invoke_downstream(headers) except RequestException: # when there's an issue a span can be tagged with error to flag it in haystack trends child_scope.span.set_tag(tags.ERROR, True) # be cognitive of which scope is handling the response processing. here we're back into the request_scope, thus # child_scope's span will only represent total time interacting with the downstream service lambda_response = process_downstream_response(response) return lambda_response haystack-client-python-0.2.2/haystack-idl/000077500000000000000000000000001400365540200204715ustar00rootroot00000000000000haystack-client-python-0.2.2/haystack/000077500000000000000000000000001400365540200177235ustar00rootroot00000000000000haystack-client-python-0.2.2/haystack/__init__.py000066400000000000000000000003731400365540200220370ustar00rootroot00000000000000from .tracer import HaystackTracer # noqa from .http_recorder import AsyncHttpRecorder # noqa from .http_recorder import SyncHttpRecorder # noqa from .agent_recorder import HaystackAgentRecorder # noqa from .recorder import LoggerRecorder # noqa haystack-client-python-0.2.2/haystack/agent/000077500000000000000000000000001400365540200210215ustar00rootroot00000000000000haystack-client-python-0.2.2/haystack/agent/__init__.py000066400000000000000000000000001400365540200231200ustar00rootroot00000000000000haystack-client-python-0.2.2/haystack/agent/spanAgent_pb2.py000066400000000000000000000102231400365540200240540ustar00rootroot00000000000000# Generated by the protocol buffer compiler. DO NOT EDIT! # source: agent/spanAgent.proto import sys _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf import reflection as _reflection from google.protobuf import symbol_database as _symbol_database # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from .. import span_pb2 as span__pb2 DESCRIPTOR = _descriptor.FileDescriptor( name='agent/spanAgent.proto', package='', syntax='proto3', serialized_options=_b('\n\"com.expedia.open.tracing.agent.apiP\001Z\010haystack'), serialized_pb=_b('\n\x15\x61gent/spanAgent.proto\x1a\nspan.proto\"\x95\x01\n\x0e\x44ispatchResult\x12(\n\x04\x63ode\x18\x01 \x01(\x0e\x32\x1a.DispatchResult.ResultCode\x12\x15\n\rerror_message\x18\x02 \x01(\t\"B\n\nResultCode\x12\x0b\n\x07SUCCESS\x10\x00\x12\x11\n\rUNKNOWN_ERROR\x10\x01\x12\x14\n\x10RATE_LIMIT_ERROR\x10\x02\x32/\n\tSpanAgent\x12\"\n\x08\x64ispatch\x12\x05.Span\x1a\x0f.DispatchResultB0\n\"com.expedia.open.tracing.agent.apiP\x01Z\x08haystackb\x06proto3') , dependencies=[span__pb2.DESCRIPTOR,]) _DISPATCHRESULT_RESULTCODE = _descriptor.EnumDescriptor( name='ResultCode', full_name='DispatchResult.ResultCode', filename=None, file=DESCRIPTOR, values=[ _descriptor.EnumValueDescriptor( name='SUCCESS', index=0, number=0, serialized_options=None, type=None), _descriptor.EnumValueDescriptor( name='UNKNOWN_ERROR', index=1, number=1, serialized_options=None, type=None), _descriptor.EnumValueDescriptor( name='RATE_LIMIT_ERROR', index=2, number=2, serialized_options=None, type=None), ], containing_type=None, serialized_options=None, serialized_start=121, serialized_end=187, ) _sym_db.RegisterEnumDescriptor(_DISPATCHRESULT_RESULTCODE) _DISPATCHRESULT = _descriptor.Descriptor( name='DispatchResult', full_name='DispatchResult', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='code', full_name='DispatchResult.code', index=0, number=1, type=14, cpp_type=8, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='error_message', full_name='DispatchResult.error_message', index=1, number=2, type=9, cpp_type=9, label=1, has_default_value=False, default_value=_b("").decode('utf-8'), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ _DISPATCHRESULT_RESULTCODE, ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=38, serialized_end=187, ) _DISPATCHRESULT.fields_by_name['code'].enum_type = _DISPATCHRESULT_RESULTCODE _DISPATCHRESULT_RESULTCODE.containing_type = _DISPATCHRESULT DESCRIPTOR.message_types_by_name['DispatchResult'] = _DISPATCHRESULT _sym_db.RegisterFileDescriptor(DESCRIPTOR) DispatchResult = _reflection.GeneratedProtocolMessageType('DispatchResult', (_message.Message,), dict( DESCRIPTOR = _DISPATCHRESULT, __module__ = 'agent.spanAgent_pb2' # @@protoc_insertion_point(class_scope:DispatchResult) )) _sym_db.RegisterMessage(DispatchResult) DESCRIPTOR._options = None _SPANAGENT = _descriptor.ServiceDescriptor( name='SpanAgent', full_name='SpanAgent', file=DESCRIPTOR, index=0, serialized_options=None, serialized_start=189, serialized_end=236, methods=[ _descriptor.MethodDescriptor( name='dispatch', full_name='SpanAgent.dispatch', index=0, containing_service=None, input_type=span__pb2._SPAN, output_type=_DISPATCHRESULT, serialized_options=None, ), ]) _sym_db.RegisterServiceDescriptor(_SPANAGENT) DESCRIPTOR.services_by_name['SpanAgent'] = _SPANAGENT # @@protoc_insertion_point(module_scope) haystack-client-python-0.2.2/haystack/agent/spanAgent_pb2_grpc.py000066400000000000000000000026121400365540200250720ustar00rootroot00000000000000# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! import grpc from . import spanAgent_pb2 as agent_dot_spanAgent__pb2 from .. import span_pb2 as span__pb2 class SpanAgentStub(object): """service interface to push spans to haystack agent """ def __init__(self, channel): """Constructor. Args: channel: A grpc.Channel. """ self.dispatch = channel.unary_unary( '/SpanAgent/dispatch', request_serializer=span__pb2.Span.SerializeToString, response_deserializer=agent_dot_spanAgent__pb2.DispatchResult.FromString, ) class SpanAgentServicer(object): """service interface to push spans to haystack agent """ def dispatch(self, request, context): """dispatch span to haystack agent """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details('Method not implemented!') raise NotImplementedError('Method not implemented!') def add_SpanAgentServicer_to_server(servicer, server): rpc_method_handlers = { 'dispatch': grpc.unary_unary_rpc_method_handler( servicer.dispatch, request_deserializer=span__pb2.Span.FromString, response_serializer=agent_dot_spanAgent__pb2.DispatchResult.SerializeToString, ), } generic_handler = grpc.method_handlers_generic_handler( 'SpanAgent', rpc_method_handlers) server.add_generic_rpc_handlers((generic_handler,)) haystack-client-python-0.2.2/haystack/agent_recorder.py000066400000000000000000000025451400365540200232660ustar00rootroot00000000000000import grpc import logging from haystack.recorder import SpanRecorder from haystack.agent import spanAgent_pb2_grpc from haystack.util import span_to_proto logger = logging.getLogger(__name__) class HaystackAgentRecorder(SpanRecorder): """ HaystackAgentRecorder is to be used with the haystack-agent described here (https://github.com/ExpediaInc/haystack-agent) """ def __init__(self, agent_host="haystack-agent", agent_port=35000): logger.info("Initializing the remote grpc agent recorder, connecting " f"at {agent_host}:{agent_port}") channel = grpc.insecure_channel(f"{agent_host}:{agent_port}") self._stub = spanAgent_pb2_grpc.SpanAgentStub(channel) @staticmethod def process_response(future): try: grpc_response = future.result() if grpc_response.code != 0: logger.error(f"Dispatch failed with {grpc_response.code} due " f"to {grpc_response.error_message}") else: logger.debug("Successfully submitted span to haystack-agent") except grpc.RpcError: logger.exception(f"Dispatch failed due to RPC error") def record_span(self, span): future = self._stub.dispatch.future(span_to_proto(span)) future.add_done_callback(HaystackAgentRecorder.process_response) haystack-client-python-0.2.2/haystack/binary_propagator.py000066400000000000000000000004411400365540200240160ustar00rootroot00000000000000from .propagator import Propagator # TODO build me for IPC purposes (use TextPropagator instead for now) class BinaryPropagator(Propagator): """A propagator for Format.BINARY""" def inject(self, span_context, carrier): pass def extract(self, carrier): pass haystack-client-python-0.2.2/haystack/constants.py000066400000000000000000000007431400365540200223150ustar00rootroot00000000000000# Name of the HTTP header or Key used to encode Trace ID TRACE_ID = "Trace-ID" # Name of the HTTP header or Key used to encode Span ID SPAN_ID = "Span-ID" # Name of the HTTP header or Key used to encode Parent Span ID PARENT_SPAN_ID = "Parent-ID" # Prefix of the HTTP header or Key used to encode Baggage items BAGGAGE_PREFIX = "Baggage-" # The number of microseconds in one second SECONDS_TO_MICRO = 1000000 # The default HTTP recorder timeout value DEFAULT_HTTP_TIMEOUT = 5.0 haystack-client-python-0.2.2/haystack/http_recorder.py000066400000000000000000000105711400365540200231450ustar00rootroot00000000000000import logging import json from requests import Session from requests import RequestException from requests_futures.sessions import FuturesSession from .recorder import SpanRecorder from .util import span_to_proto, span_to_json from .constants import DEFAULT_HTTP_TIMEOUT logger = logging.getLogger(__name__) def response_hook(response, *args, **kwargs): if response.status_code in range(200, 203): logger.debug("successfully submitted the span to http collector") else: logger.error(f"Failed to submit span to the http collector. " f"Haystack Response: {response}") class SyncHttpRecorder(SpanRecorder): """Http span recorder which Translates and reports haystack.Spans in-process.""" def __init__(self, collector_url="http://haystack-collector:8080/span", headers={}, timeout_seconds=DEFAULT_HTTP_TIMEOUT, use_json_payload=False, requests_session=None): """ :param collector_url: the haystack collector endpoint :param timeout_seconds: timeout limit of the requests :param use_json_payload: set True to enable json payload format. """ self._collector_url = collector_url self._timeout_seconds = timeout_seconds self._use_json_payload = use_json_payload self._session = requests_session or Session() headers["Content-Type"] = "application/json" if use_json_payload \ else "application/octet-stream" self._session.headers.update(headers) self._session.hooks["response"] = response_hook @staticmethod def get_json_payload(span): json_span = span_to_json(span) str_span = json.dumps( json_span, default=lambda o: f"{o.__class__.__name__} is not serializable" ) return str_span.encode("utf-8") @staticmethod def get_binary_payload(span): proto_span = span_to_proto(span) return proto_span.SerializeToString() def post_payload(self, payload): try: logger.debug(f"Haystack Payload = {payload}") self._session.post(self._collector_url, data=payload, timeout=self._timeout_seconds) except RequestException as e: logger.error(f"Failed to submit span to the http collector due " f"to {e}") def record_span(self, span): try: payload = self.get_json_payload(span) if self._use_json_payload \ else self.get_binary_payload(span) except TypeError: logger.exception("failed to convert span") self.post_payload(payload) class ExceptionHandlingRequestsSession(Session): """This class is needed to prevent exceptions from being swallowed due to the async recorder not calling .result() on the future.""" def send(self, request, **kwargs): try: super().send(request, **kwargs) except RequestException as e: logger.error(f"Failed to submit span to the http collector due " f"to {e}") class AsyncHttpRecorder(SyncHttpRecorder): """Http span recorder which Translates and reports haystack.Spans via threaded executor pool. """ def __init__(self, collector_url="http://haystack-collector:8080/span", headers={}, timeout_seconds=DEFAULT_HTTP_TIMEOUT, use_json_payload=False, executor=None): """ :param collector_url: the haystack collector endpoint :param timeout_seconds: timeout limit of the requests (these are handled on a background thread) :param use_json_payload: set True to enable json payload format. :param executor: Can provide a ProcessExecutor pool or ThreadExecutor pool with tuned parameters. Default is a ThreadExecutorPool with max 8 threads """ super().__init__(collector_url=collector_url, headers=headers, timeout_seconds=timeout_seconds, use_json_payload=use_json_payload, requests_session=ExceptionHandlingRequestsSession()) self._session = FuturesSession(executor=executor, session=self._session) haystack-client-python-0.2.2/haystack/propagator.py000066400000000000000000000014031400365540200224510ustar00rootroot00000000000000from abc import ABC, abstractmethod from collections import namedtuple from .constants import ( TRACE_ID, SPAN_ID, PARENT_SPAN_ID, BAGGAGE_PREFIX, ) class Propagator(ABC): @abstractmethod def inject(self, span_context, carrier): raise NotImplementedError() @abstractmethod def extract(self, carrier): raise NotImplementedError() PropagatorOpts = namedtuple("PropagatorOpts", ["trace_id_key", "span_id_key", "parent_id_key", "baggage_key_prefix"]) PropagatorOpts.__new__.__defaults__ = (TRACE_ID, SPAN_ID, PARENT_SPAN_ID, BAGGAGE_PREFIX) haystack-client-python-0.2.2/haystack/recorder.py000066400000000000000000000012731400365540200221050ustar00rootroot00000000000000import logging from abc import ABC, abstractmethod from .util import span_to_string logger = logging.getLogger(__name__) class SpanRecorder(ABC): """A recorder translates and reports finished :class:`Spans`.""" @abstractmethod def record_span(self, span): """After the call to finish(), each Span is passed as `span` to SpanRecorder.record_span. :param BasicSpan span: the finish()'d Span object. """ raise NotImplementedError() class NoopRecorder(SpanRecorder): def record_span(self, span): pass class LoggerRecorder(SpanRecorder): def record_span(self, span): logger.info(f"SpanRecord = {span_to_string(span)}") haystack-client-python-0.2.2/haystack/span.py000066400000000000000000000114621400365540200212420ustar00rootroot00000000000000import opentracing import time from threading import Lock class SpanContext(opentracing.SpanContext): """Implements opentracing.SpanContext""" def __init__(self, trace_id=None, span_id=None, parent_id=None, baggage=None): self.trace_id = trace_id self.span_id = span_id self.parent_id = parent_id self._baggage = baggage or opentracing.SpanContext.EMPTY_BAGGAGE @property def baggage(self): return self._baggage or opentracing.SpanContext.EMPTY_BAGGAGE def with_baggage_item(self, key, value): baggage = dict(self._baggage) if value is not None: baggage[key] = value else: baggage.pop(key, None) return SpanContext(trace_id=self.trace_id, span_id=self.span_id, parent_id=self.parent_id, baggage=baggage) class Span(opentracing.Span): """Implements opentracing.Span""" def __init__( self, tracer, operation_name=None, context=None, tags=None, start_time=None): super().__init__(tracer, context) self._tracer = tracer self._mutex = Lock() self.operation_name = operation_name self.start_time = start_time self.tags = tags if tags is not None else {} self.duration = -1 self.logs = [] def set_operation_name(self, operation_name): with self._mutex: self.operation_name = operation_name return self def set_tag(self, key, value): """Attaches a key/value pair to the :class:`Span`. The value must be a string, a bool, or a numeric type. If the user calls set_tag multiple times for the same key, the behavior of the :class:`Tracer` is undefined, i.e. it is implementation specific whether the :class:`Tracer` will retain the first value, or the last value, or pick one randomly, or even keep all of them. :param key: key or name of the tag. Must be a string. :type key: str :param value: value of the tag. :type value: string or bool or int or float :rtype: Span :return: the :class:`Span` itself, for call chaining. """ with self._mutex: if self.tags is None: self.tags = {} self.tags[key] = value return self def log_kv(self, key_values, timestamp=None): """Adds a log record to the :class:`Span`. For example:: span.log_kv({ "event": "time to first byte", "packet.size": packet.size()}) span.log_kv({"event": "two minutes ago"}, time.time() - 120) :param key_values: A dict of string keys and values of any type :type key_values: dict :param timestamp: A unix timestamp per :meth:`time.time()`; current time if ``None`` :type timestamp: float :rtype: Span :return: the :class:`Span` itself, for call chaining. """ with self._mutex: self.logs.append(LogData(key_values, timestamp)) return self def finish(self, finish_time=None): with self._mutex: finish = time.time() if finish_time is None else finish_time self.duration = finish - self.start_time self._tracer.record(self) def set_baggage_item(self, key, value): """Stores a Baggage item in the :class:`Span` as a key/value pair. Enables powerful distributed context propagation functionality where arbitrary application data can be carried along the full path of request execution throughout the system. Note 1: Baggage is only propagated to the future (recursive) children of this :class:`Span`. Note 2: Baggage is sent in-band with every subsequent local and remote calls, so this feature must be used with care. (Don't create too much baggage :) Note 3: Baggage is not visible in haystack UI. IPC communication only. :param key: Baggage item key :type key: str :param value: Baggage item value :type value: str :rtype: Span :return: itself, for chaining the calls. """ new_ctx = self.context.with_baggage_item(key=key, value=value) with self._mutex: self._context = new_ctx return self def get_baggage_item(self, key): with self._mutex: return self.context.baggage.get(key) class LogData(object): def __init__(self, key_values, timestamp=None): self.key_values = key_values self.timestamp = time.time() if timestamp is None else timestamp haystack-client-python-0.2.2/haystack/span_pb2.py000066400000000000000000000316331400365540200220070ustar00rootroot00000000000000# Generated by the protocol buffer compiler. DO NOT EDIT! # source: span.proto import sys _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf import reflection as _reflection from google.protobuf import symbol_database as _symbol_database # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() DESCRIPTOR = _descriptor.FileDescriptor( name='span.proto', package='', syntax='proto3', serialized_options=_b('\n\030com.expedia.open.tracingP\001Z\010haystack'), serialized_pb=_b('\n\nspan.proto\"\xb6\x01\n\x04Span\x12\x0f\n\x07traceId\x18\x01 \x01(\t\x12\x0e\n\x06spanId\x18\x02 \x01(\t\x12\x14\n\x0cparentSpanId\x18\x03 \x01(\t\x12\x13\n\x0bserviceName\x18\x04 \x01(\t\x12\x15\n\roperationName\x18\x05 \x01(\t\x12\x11\n\tstartTime\x18\x06 \x01(\x03\x12\x10\n\x08\x64uration\x18\x07 \x01(\x03\x12\x12\n\x04logs\x18\x08 \x03(\x0b\x32\x04.Log\x12\x12\n\x04tags\x18\t \x03(\x0b\x32\x04.Tag\".\n\x03Log\x12\x11\n\ttimestamp\x18\x01 \x01(\x03\x12\x14\n\x06\x66ields\x18\x02 \x03(\x0b\x32\x04.Tag\"\xd3\x01\n\x03Tag\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x1a\n\x04type\x18\x02 \x01(\x0e\x32\x0c.Tag.TagType\x12\x0e\n\x04vStr\x18\x03 \x01(\tH\x00\x12\x0f\n\x05vLong\x18\x04 \x01(\x03H\x00\x12\x11\n\x07vDouble\x18\x05 \x01(\x01H\x00\x12\x0f\n\x05vBool\x18\x06 \x01(\x08H\x00\x12\x10\n\x06vBytes\x18\x07 \x01(\x0cH\x00\"A\n\x07TagType\x12\n\n\x06STRING\x10\x00\x12\n\n\x06\x44OUBLE\x10\x01\x12\x08\n\x04\x42OOL\x10\x02\x12\x08\n\x04LONG\x10\x03\x12\n\n\x06\x42INARY\x10\x04\x42\t\n\x07myvalue\"\x1d\n\x05\x42\x61tch\x12\x14\n\x05spans\x18\x01 \x03(\x0b\x32\x05.SpanB&\n\x18\x63om.expedia.open.tracingP\x01Z\x08haystackb\x06proto3') ) _TAG_TAGTYPE = _descriptor.EnumDescriptor( name='TagType', full_name='Tag.TagType', filename=None, file=DESCRIPTOR, values=[ _descriptor.EnumValueDescriptor( name='STRING', index=0, number=0, serialized_options=None, type=None), _descriptor.EnumValueDescriptor( name='DOUBLE', index=1, number=1, serialized_options=None, type=None), _descriptor.EnumValueDescriptor( name='BOOL', index=2, number=2, serialized_options=None, type=None), _descriptor.EnumValueDescriptor( name='LONG', index=3, number=3, serialized_options=None, type=None), _descriptor.EnumValueDescriptor( name='BINARY', index=4, number=4, serialized_options=None, type=None), ], containing_type=None, serialized_options=None, serialized_start=383, serialized_end=448, ) _sym_db.RegisterEnumDescriptor(_TAG_TAGTYPE) _SPAN = _descriptor.Descriptor( name='Span', full_name='Span', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='traceId', full_name='Span.traceId', index=0, number=1, type=9, cpp_type=9, label=1, has_default_value=False, default_value=_b("").decode('utf-8'), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='spanId', full_name='Span.spanId', index=1, number=2, type=9, cpp_type=9, label=1, has_default_value=False, default_value=_b("").decode('utf-8'), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='parentSpanId', full_name='Span.parentSpanId', index=2, number=3, type=9, cpp_type=9, label=1, has_default_value=False, default_value=_b("").decode('utf-8'), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='serviceName', full_name='Span.serviceName', index=3, number=4, type=9, cpp_type=9, label=1, has_default_value=False, default_value=_b("").decode('utf-8'), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='operationName', full_name='Span.operationName', index=4, number=5, type=9, cpp_type=9, label=1, has_default_value=False, default_value=_b("").decode('utf-8'), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='startTime', full_name='Span.startTime', index=5, number=6, type=3, cpp_type=2, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='duration', full_name='Span.duration', index=6, number=7, type=3, cpp_type=2, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='logs', full_name='Span.logs', index=7, number=8, type=11, cpp_type=10, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='tags', full_name='Span.tags', index=8, number=9, type=11, cpp_type=10, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=15, serialized_end=197, ) _LOG = _descriptor.Descriptor( name='Log', full_name='Log', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='timestamp', full_name='Log.timestamp', index=0, number=1, type=3, cpp_type=2, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='fields', full_name='Log.fields', index=1, number=2, type=11, cpp_type=10, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=199, serialized_end=245, ) _TAG = _descriptor.Descriptor( name='Tag', full_name='Tag', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='key', full_name='Tag.key', index=0, number=1, type=9, cpp_type=9, label=1, has_default_value=False, default_value=_b("").decode('utf-8'), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='type', full_name='Tag.type', index=1, number=2, type=14, cpp_type=8, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='vStr', full_name='Tag.vStr', index=2, number=3, type=9, cpp_type=9, label=1, has_default_value=False, default_value=_b("").decode('utf-8'), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='vLong', full_name='Tag.vLong', index=3, number=4, type=3, cpp_type=2, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='vDouble', full_name='Tag.vDouble', index=4, number=5, type=1, cpp_type=5, label=1, has_default_value=False, default_value=float(0), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='vBool', full_name='Tag.vBool', index=5, number=6, type=8, cpp_type=7, label=1, has_default_value=False, default_value=False, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='vBytes', full_name='Tag.vBytes', index=6, number=7, type=12, cpp_type=9, label=1, has_default_value=False, default_value=_b(""), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ _TAG_TAGTYPE, ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ _descriptor.OneofDescriptor( name='myvalue', full_name='Tag.myvalue', index=0, containing_type=None, fields=[]), ], serialized_start=248, serialized_end=459, ) _BATCH = _descriptor.Descriptor( name='Batch', full_name='Batch', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='spans', full_name='Batch.spans', index=0, number=1, type=11, cpp_type=10, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=461, serialized_end=490, ) _SPAN.fields_by_name['logs'].message_type = _LOG _SPAN.fields_by_name['tags'].message_type = _TAG _LOG.fields_by_name['fields'].message_type = _TAG _TAG.fields_by_name['type'].enum_type = _TAG_TAGTYPE _TAG_TAGTYPE.containing_type = _TAG _TAG.oneofs_by_name['myvalue'].fields.append( _TAG.fields_by_name['vStr']) _TAG.fields_by_name['vStr'].containing_oneof = _TAG.oneofs_by_name['myvalue'] _TAG.oneofs_by_name['myvalue'].fields.append( _TAG.fields_by_name['vLong']) _TAG.fields_by_name['vLong'].containing_oneof = _TAG.oneofs_by_name['myvalue'] _TAG.oneofs_by_name['myvalue'].fields.append( _TAG.fields_by_name['vDouble']) _TAG.fields_by_name['vDouble'].containing_oneof = _TAG.oneofs_by_name['myvalue'] _TAG.oneofs_by_name['myvalue'].fields.append( _TAG.fields_by_name['vBool']) _TAG.fields_by_name['vBool'].containing_oneof = _TAG.oneofs_by_name['myvalue'] _TAG.oneofs_by_name['myvalue'].fields.append( _TAG.fields_by_name['vBytes']) _TAG.fields_by_name['vBytes'].containing_oneof = _TAG.oneofs_by_name['myvalue'] _BATCH.fields_by_name['spans'].message_type = _SPAN DESCRIPTOR.message_types_by_name['Span'] = _SPAN DESCRIPTOR.message_types_by_name['Log'] = _LOG DESCRIPTOR.message_types_by_name['Tag'] = _TAG DESCRIPTOR.message_types_by_name['Batch'] = _BATCH _sym_db.RegisterFileDescriptor(DESCRIPTOR) Span = _reflection.GeneratedProtocolMessageType('Span', (_message.Message,), dict( DESCRIPTOR = _SPAN, __module__ = 'span_pb2' # @@protoc_insertion_point(class_scope:Span) )) _sym_db.RegisterMessage(Span) Log = _reflection.GeneratedProtocolMessageType('Log', (_message.Message,), dict( DESCRIPTOR = _LOG, __module__ = 'span_pb2' # @@protoc_insertion_point(class_scope:Log) )) _sym_db.RegisterMessage(Log) Tag = _reflection.GeneratedProtocolMessageType('Tag', (_message.Message,), dict( DESCRIPTOR = _TAG, __module__ = 'span_pb2' # @@protoc_insertion_point(class_scope:Tag) )) _sym_db.RegisterMessage(Tag) Batch = _reflection.GeneratedProtocolMessageType('Batch', (_message.Message,), dict( DESCRIPTOR = _BATCH, __module__ = 'span_pb2' # @@protoc_insertion_point(class_scope:Batch) )) _sym_db.RegisterMessage(Batch) DESCRIPTOR._options = None # @@protoc_insertion_point(module_scope) haystack-client-python-0.2.2/haystack/text_propagator.py000066400000000000000000000042561400365540200235260ustar00rootroot00000000000000from .propagator import Propagator, PropagatorOpts from .span import SpanContext from opentracing import SpanContextCorruptedException class TextPropagator(Propagator): """A propagator for Format.TEXT_MAP and Format.HTTP_HEADERS""" def __init__(self, propagator_opts=None): """ Initialize with optional custom keys for the carrier. :param propagator_opts: PropagatorOps named tuple with custom keys to inject and extract :class:SpanContext from the carrier. """ self._propagator_opts = propagator_opts or PropagatorOpts() def inject(self, span_context, carrier): carrier[self._propagator_opts.trace_id_key] = span_context.trace_id carrier[self._propagator_opts.span_id_key] = span_context.span_id carrier[self._propagator_opts.parent_id_key] = span_context.parent_id if span_context.baggage is not None: for item in span_context.baggage: carrier[self._propagator_opts.baggage_key_prefix + item] = \ span_context.baggage[item] def extract(self, carrier): count = 0 baggage = {} parent_id = None for key in carrier: lc_key = key.lower() value = carrier[key] if lc_key == self._propagator_opts.span_id_key.lower(): span_id = value count += 1 elif lc_key == self._propagator_opts.trace_id_key.lower(): trace_id = value count += 1 elif lc_key.startswith( self._propagator_opts.baggage_key_prefix.lower()): baggage[ key[len(self._propagator_opts.baggage_key_prefix):]] = \ value elif lc_key == self._propagator_opts.parent_id_key.lower(): parent_id = value if count == 0: return None elif count != 2: raise SpanContextCorruptedException( "Both SpanID and TraceID are required") return SpanContext(span_id=span_id, trace_id=trace_id, parent_id=parent_id, baggage=baggage) haystack-client-python-0.2.2/haystack/tracer.py000066400000000000000000000120471400365540200215610ustar00rootroot00000000000000import time import uuid from opentracing import Format, Tracer, UnsupportedFormatException from opentracing.scope_managers import ThreadLocalScopeManager from .text_propagator import TextPropagator from .span import Span, SpanContext class HaystackTracer(Tracer): def __init__(self, service_name, recorder, scope_manager=None, common_tags=None, use_shared_spans=False): """ Initialize a Haystack Tracer instance. :param service_name: The service name to which all spans will belong. :param recorder: The recorder (dispatcher) implementation which handles finished spans. :param scope_manager: An optional parameter to override the default ThreadLocal scope manager. :param common_tags: An optional dictionary of tags which should be applied to all created spans for this service :param use_shared_spans: A boolean indicating whether or not to use shared spans. This is when client/server spans share the same span id. Default is to use unique span ids. """ scope_manager = ThreadLocalScopeManager() if scope_manager is None \ else scope_manager super().__init__(scope_manager) self._propagators = {} self._common_tags = {} if common_tags is None else common_tags self.service_name = service_name self.recorder = recorder self.use_shared_spans = use_shared_spans self.register_propagator(Format.TEXT_MAP, TextPropagator()) self.register_propagator(Format.HTTP_HEADERS, TextPropagator()) def register_propagator(self, format, propagator): """Register a propagator with this Tracer. :param string format: a Format identifier like Format.TEXT_MAP :param Propagator propagator: a Propagator instance to handle inject/extract calls """ self._propagators[format] = propagator def start_active_span(self, operation_name, child_of=None, references=None, tags=None, start_time=None, ignore_active_span=False, finish_on_close=True): span = self.start_span(operation_name=operation_name, child_of=child_of, references=references, tags=tags, start_time=start_time, ignore_active_span=ignore_active_span) return self.scope_manager.activate(span, finish_on_close) def start_span(self, operation_name=None, child_of=None, references=None, tags=None, start_time=None, ignore_active_span=False): start_time = time.time() if start_time is None else start_time # Check for an existing ctx in `references` parent_ctx = None if child_of is not None: parent_ctx = (child_of if isinstance(child_of, SpanContext) else child_of.context) elif references is not None and len(references) > 0: parent_ctx = references[0].referenced_context # Check for an active span in scope manager if not ignore_active_span and parent_ctx is None: scope = self.scope_manager.active if scope is not None: parent_ctx = scope.span.context new_ctx = SpanContext(span_id=format(uuid.uuid4())) if parent_ctx is not None: new_ctx.trace_id = parent_ctx.trace_id if parent_ctx.baggage is not None: new_ctx._baggage = parent_ctx.baggage.copy() if self.use_shared_spans: new_ctx.span_id = parent_ctx.span_id new_ctx.parent_id = parent_ctx.parent_id else: new_ctx.parent_id = parent_ctx.span_id else: new_ctx.trace_id = format(uuid.uuid4()) # Set common tags if self._common_tags: tags = {**self._common_tags, **tags} if tags else \ self._common_tags.copy() return Span(self, operation_name=operation_name, context=new_ctx, tags=tags, start_time=start_time) def inject(self, span_context, format, carrier): if format in self._propagators: self._propagators[format].inject(span_context, carrier) else: raise UnsupportedFormatException() def extract(self, format, carrier): if format in self._propagators: return self._propagators[format].extract(carrier) else: raise UnsupportedFormatException() def record(self, span): self.recorder.record_span(span) def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): pass haystack-client-python-0.2.2/haystack/util.py000066400000000000000000000100701400365540200212500ustar00rootroot00000000000000from .span_pb2 import Span, Tag from .constants import SECONDS_TO_MICRO from types import TracebackType import numbers import logging import json import traceback logger = logging.getLogger("haystack") def tags_as_list(tags): tag_list = [] for key, value in tags.items(): tag_list.append({"key": key, "value": value}) return tag_list def logs_as_list(logs): log_list = [] for log_data in logs: kv_pairs = [] for key, value in log_data.key_values.items(): kv_pairs.append({"key": key, "value": value}) log_list.append( {"timestamp": int(log_data.timestamp * SECONDS_TO_MICRO), "fields": kv_pairs}) return log_list def set_proto_tag_value(tag, value): if isinstance(value, str): tag.vStr = value tag.type = Tag.STRING elif isinstance(value, bool): tag.vBool = value tag.type = Tag.BOOL elif isinstance(value, numbers.Integral): tag.vLong = value tag.type = Tag.LONG elif isinstance(value, float): tag.vDouble = value tag.type = Tag.DOUBLE elif isinstance(value, bytes): tag.vBytes = value tag.type = Tag.BINARY elif isinstance(value, dict): tag.vStr = json.dumps(value) tag.type = Tag.STRING elif isinstance(value, type): tag.vStr = str(value) tag.type = Tag.STRING elif isinstance(value, TracebackType): tag.vStr = str(traceback.format_tb(value)) tag.type = Tag.STRING else: logger.error(f"Dropped tag {tag.key} due to " f"invalid value type of {type(value)}. " f"Type must be Int, String, Bool, Float, Dict or Bytes") tag.vStr = f"Unserializable object type: {str(type(value))}" tag.type = Tag.STRING def add_proto_tags(span_record, tags): for key, value in tags.items(): tag = span_record.tags.add() tag.key = key set_proto_tag_value(tag, value) def add_proto_logs(span_record, span_logs): for log_data in span_logs: log_record = span_record.logs.add() log_record.timestamp = int(log_data.timestamp * SECONDS_TO_MICRO) for key, value in log_data.key_values.items(): tag = log_record.fields.add() tag.key = key set_proto_tag_value(tag, value) def span_to_proto(span): span_record = Span(traceId=span.context.trace_id, spanId=span.context.span_id, parentSpanId=span.context.parent_id, serviceName=span.tracer.service_name, operationName=span.operation_name, startTime=int(span.start_time * SECONDS_TO_MICRO), duration=int(span.duration * SECONDS_TO_MICRO)) add_proto_tags(span_record, span.tags) add_proto_logs(span_record, span.logs) return span_record def span_to_json(span): return { "traceId": span.context.trace_id, "spanId": span.context.span_id, "parentSpanId": span.context.parent_id, "serviceName": span.tracer.service_name, "operationName": span.operation_name, "startTime": int(span.start_time * SECONDS_TO_MICRO), "duration": int(span.duration * SECONDS_TO_MICRO), "tags": tags_as_list(span.tags), "logs": logs_as_list(span.logs) } def span_to_string(span): record = "Operation=" record += span.operation_name record += ", TraceId=" record += span.context.trace_id record += ", SpanId=" record += span.context.span_id if span.context.parent_id: record += ", ParentSpanId=" record += span.context.parent_id if span.context.baggage: record += str(span.context.baggage) if span.tags: record += ", Tags=" + str(tags_as_list(span.tags)) if span.logs: record += ", Logs=" + str(logs_as_list(span.logs)) record += ", StartTime=" record += str(int(span.start_time * SECONDS_TO_MICRO)) record += ", Duration=" record += str(int(span.duration * SECONDS_TO_MICRO)) return record haystack-client-python-0.2.2/requirements.txt000066400000000000000000000000401400365540200213720ustar00rootroot00000000000000# add dependencies in setup.py .haystack-client-python-0.2.2/scripts/000077500000000000000000000000001400365540200176035ustar00rootroot00000000000000haystack-client-python-0.2.2/scripts/version.py000066400000000000000000000031771400365540200216520ustar00rootroot00000000000000import requests import json import semver import os VERSION_PLACEHOLDER = "X.X.X" def update_setup(new_version): with open("setup.py") as f: content = f.read() if VERSION_PLACEHOLDER not in content: raise Exception("setup.py version parameter has been modified") with open("setup.py", "w") as f: print("changing setup.py version parameter") content = content.replace(VERSION_PLACEHOLDER, new_version) f.write(content) def pypi_version(response): data = json.loads(response.text) if "info" in data: return data["info"]["version"] else: raise Exception(f"Invalid response {data} from pypi. " f"info tag missing") if __name__ == "__main__": tag_ver = os.getenv("TRAVIS_TAG") if tag_ver is None: raise TypeError("Expected TRAVIS_TAG environment variable to be set") # verify tag is valid semver semver.parse(tag_ver) response = requests.get("https://pypi.org/pypi/haystack-client/json") if response.ok: old_ver = pypi_version(response) elif response.status_code == 404: print("must be a new repo") old_ver = "0.0.0" else: raise Exception(f"Failed to get existing version information from pypi." f" Response was {response}") if semver.compare(tag_ver, old_ver) > 0: print(f"Previouis PyPI version is {old_ver}, updating setup.py with new" f" version {tag_ver}") update_setup(tag_ver) else: raise Exception(f"pypi version {old_ver} is newer than tagged version" f" {tag_ver}") haystack-client-python-0.2.2/setup.py000066400000000000000000000025621400365540200176330ustar00rootroot00000000000000from setuptools import setup, find_packages with open("README.md") as file: long_description = file.read() setup( name="haystack-client", version="X.X.X", # do not change, makefile updates this prior to a release url="https://github.com/ExpediaDotCom/haystack-client-python", description="Haystack Python OpenTracing Implementation", author="Ryan Hilfers, Haystack", author_email="haystack@expediagroup.com", long_description=long_description, long_description_content_type="text/markdown", install_requires=["opentracing>=2.3.0,<3.0", "requests>=2.19,<3.0", "requests-futures>=0.9.9,<1.0", "protobuf>=3.11.2,<4.0", "grpcio>=1.26.0,<2.0"], tests_require=["mock", "nose", "pytest", "coverage",], test_suite="nose.collector", classifiers=[ "Programming Language :: Python :: 3.5", "Programming Language :: Python :: 3.6", "Programming Language :: Python :: 3.7", "Programming Language :: Python :: 3.8", "Operating System :: OS Independent", "License :: OSI Approved :: Apache Software License", ], python_requires=">=3.5", keywords=["opentracing", "haystack", "tracing", "microservices", "distributed"], packages=find_packages() ) haystack-client-python-0.2.2/tests/000077500000000000000000000000001400365540200172565ustar00rootroot00000000000000haystack-client-python-0.2.2/tests/integration/000077500000000000000000000000001400365540200216015ustar00rootroot00000000000000haystack-client-python-0.2.2/tests/integration/docker-compose.yml000066400000000000000000000020721400365540200252370ustar00rootroot00000000000000version: '3' services: haystack_agent: image: expediadotcom/haystack-agent:0.1.3 depends_on: - zookeeper - kafkasvc environment: haystack_env_agents_spans_port: 35000 haystack_env_agents_spans_dispatchers_kafka_bootstrap_servers: "kafkasvc:9092" ports: - "35000:35000" entrypoint: - /bin/sh - -c - 'sleep 10 && java -jar /app/bin/haystack-agent.jar --config-provider file --file-path /app/bin/dev.conf' haystack_collector: image: expediadotcom/haystack-http-span-collector:1.1 depends_on: - zookeeper - kafkasvc environment: HAYSTACK_PROP_KAFKA_PRODUCER_PROPS_BOOTSTRAP_SERVERS: "kafkasvc:9092" ports: - "8080:8080" zookeeper: image: wurstmeister/zookeeper ports: - "2181:2181" kafkasvc: image: wurstmeister/kafka:2.11-1.1.1 depends_on: - zookeeper environment: KAFKA_ADVERTISED_HOST_NAME: "kafkasvc" KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181 volumes: - /var/run/docker.sock:/var/run/docker.sock ports: - "9092:9092"haystack-client-python-0.2.2/tests/integration/integration.py000066400000000000000000000061331400365540200245010ustar00rootroot00000000000000import opentracing import logging import unittest from kafka import KafkaConsumer import threading import time from haystack.span_pb2 import Span from haystack import HaystackTracer from haystack import HaystackAgentRecorder from haystack import AsyncHttpRecorder logging.basicConfig(level=logging.INFO) consumer = KafkaConsumer("proto-spans", bootstrap_servers="kafkasvc:9092") def send_a_span(span_name): time.sleep(1.0) # give kafka consumer a second to connect span = opentracing.tracer.start_span(span_name) span.set_tag("span.kind", "server") client_span = opentracing.tracer.start_span(f"{span_name}-client", child_of=span.context) client_span.set_tag("span.kind", "client") client_span.finish() span.finish() def get_spans(): spans = {} for i in range(2): print("waiting for next record") msg = next(consumer) print(f"found span = {msg}") span = Span() span.ParseFromString(msg.value) if span.tags.pop().vStr == "client": spans["client"] = span else: spans["server"] = span return spans class HaystackIntegrationTests(unittest.TestCase): """ Note: If running in IDE, need to provide 'localhost' hostname to both recorders """ def test_haystack_agent(self): span_name = "agent-test-span" service_name = "agent-test" opentracing.tracer = HaystackTracer(service_name, HaystackAgentRecorder("sandbox_haystack_agent_1")) thread = threading.Thread(target=send_a_span, args=(span_name,)) thread.start() retrieved_spans = get_spans() client_span = retrieved_spans["client"] server_span = retrieved_spans["server"] self.assertEqual(f"{span_name}-client", client_span.operationName) self.assertEqual(span_name, server_span.operationName) self.assertEqual(service_name, server_span.serviceName) self.assertEqual(service_name, client_span.serviceName) self.assertEqual(client_span.parentSpanId, server_span.spanId) self.assertEqual(client_span.traceId, server_span.traceId) def test_http_collector(self): span_name = "http-test-span" service_name = "http-test" opentracing.tracer = HaystackTracer(service_name, AsyncHttpRecorder( collector_url="http://sandbox_haystack_collector_1:8080/span")) thread = threading.Thread(target=send_a_span, args=(span_name,)) thread.start() retrieved_spans = get_spans() client_span = retrieved_spans["client"] server_span = retrieved_spans["server"] self.assertEqual(f"{span_name}-client", client_span.operationName) self.assertEqual(span_name, server_span.operationName) self.assertEqual(service_name, server_span.serviceName) self.assertEqual(service_name, client_span.serviceName) self.assertEqual(client_span.parentSpanId, server_span.spanId) self.assertEqual(client_span.traceId, server_span.traceId) if __name__ == "__main__": unittest.main() haystack-client-python-0.2.2/tests/unit/000077500000000000000000000000001400365540200202355ustar00rootroot00000000000000haystack-client-python-0.2.2/tests/unit/__init__.py000066400000000000000000000000001400365540200223340ustar00rootroot00000000000000haystack-client-python-0.2.2/tests/unit/test_http_recorder.py000066400000000000000000000101251400365540200245110ustar00rootroot00000000000000import unittest import json from unittest import mock from haystack import AsyncHttpRecorder from haystack import SyncHttpRecorder from haystack.constants import DEFAULT_HTTP_TIMEOUT class AsyncHttpRecorderTest(unittest.TestCase): def setUp(self): self.a_url = "http://fake.collector.url" @mock.patch("haystack.http_recorder.span_to_json") @mock.patch("haystack.http_recorder.FuturesSession") def test_async_recorder_with_json_payload_and_custom_timeout(self, mock_futures_session, mock_span_to_json): test_timeout = 1.0 recorder = AsyncHttpRecorder(self.a_url, timeout_seconds=test_timeout, use_json_payload=True) span_as_json = {"fake": "span"} mock_span_to_json.return_value = span_as_json recorder.record_span(mock.Mock()) expected_payload = json.dumps(span_as_json).encode("utf-8") mock_futures_session.return_value.post.assert_called_once_with(self.a_url, data=expected_payload, timeout=test_timeout) @mock.patch("haystack.http_recorder.span_to_proto") @mock.patch("haystack.http_recorder.FuturesSession") def test_async_recorder_defaults_to_proto_with_default_timeout(self, mock_futures_session, mock_span_to_proto): recorder = AsyncHttpRecorder(self.a_url, ) proto_string = "a protospan string" mock_span_to_proto.return_value.SerializeToString.return_value = proto_string recorder.record_span(mock.Mock()) mock_futures_session.return_value.post.assert_called_once_with(self.a_url, data=proto_string, timeout=DEFAULT_HTTP_TIMEOUT) class SyncHttpRecorderTest(unittest.TestCase): def setUp(self): self.a_url = "http://fake.collector.url" @mock.patch("haystack.http_recorder.span_to_json") @mock.patch("haystack.http_recorder.Session") def test_sync_recorder_with_json_payload_and_custom_timeout(self, mock_session, mock_span_to_json): test_timeout = 1.0 recorder = SyncHttpRecorder(self.a_url, timeout_seconds=test_timeout, use_json_payload=True) span_as_json = {"fake": "span"} mock_span_to_json.return_value = span_as_json recorder.record_span(mock.Mock()) expected_payload = json.dumps(span_as_json).encode("utf-8") mock_session.return_value.post.assert_called_once_with(self.a_url, data=expected_payload, timeout=test_timeout) @mock.patch("haystack.http_recorder.span_to_proto") @mock.patch("haystack.http_recorder.Session") def test_sync_recorder_defaults_to_proto_with_default_timeout(self, mock_session, mock_span_to_proto): recorder = SyncHttpRecorder(self.a_url, ) proto_string = "a protospan string" mock_span_to_proto.return_value.SerializeToString.return_value = proto_string recorder.record_span(mock.Mock()) mock_session.return_value.post.assert_called_once_with(self.a_url, data=proto_string, timeout=DEFAULT_HTTP_TIMEOUT) if __name__ == "__main__": unittest.main() haystack-client-python-0.2.2/tests/unit/test_opentracing_api_compatibility.py000066400000000000000000000025151400365540200277440ustar00rootroot00000000000000import unittest from haystack.tracer import HaystackTracer from haystack.recorder import NoopRecorder from opentracing.harness.api_check import APICompatibilityCheckMixin from opentracing import Format class ModifiedAPICompatibilityCheckMixin(APICompatibilityCheckMixin): # TODO implement binary propagator and remove this hack! def test_binary_propagation(self): pass def test_mandatory_formats(self): formats = [ (Format.TEXT_MAP, {}), (Format.HTTP_HEADERS, {}), # (Format.BINARY, bytearray()), ] with self.tracer().start_span(operation_name='Bender') as span: for fmt, carrier in formats: # expecting no exceptions span.tracer.inject(span.context, fmt, carrier) span.tracer.extract(fmt, carrier) class HaystackTracerCompatibility(unittest.TestCase, ModifiedAPICompatibilityCheckMixin): def setUp(self): self._tracer = HaystackTracer("TestTracer", NoopRecorder()) def tracer(self): return self._tracer def is_parent(self, parent, span): if span is None: return False if parent is None: return span.context.parent_id is None return parent.context.span_id == span.context.parent_id if __name__ == "__main__": unittest.main() haystack-client-python-0.2.2/tests/unit/test_text_propagator.py000066400000000000000000000051161400365540200250730ustar00rootroot00000000000000import unittest from opentracing import SpanContextCorruptedException from haystack.text_propagator import TextPropagator from haystack.propagator import PropagatorOpts from haystack.constants import ( TRACE_ID, SPAN_ID, PARENT_SPAN_ID, BAGGAGE_PREFIX, ) class TextPropagatorTest(unittest.TestCase): def setUp(self): self.propagator = TextPropagator() def test_span_id_without_trace_id_throws_exception(self): carrier = {"Span-ID": "123456", "Foo-ID": "1234567"} self.assertRaises(SpanContextCorruptedException, self.propagator.extract, carrier) def test_trace_id_without_span_id_throws_exception(self): carrier = {"Trace-ID": "123456", "Foo-ID": "1234567"} self.assertRaises(SpanContextCorruptedException, self.propagator.extract, carrier) def test_no_context_in_carrier_returns_none(self): span_id = "1234" carrier = {"Not-A-Message-ID": span_id, "Not-A-Trace-ID": "123456"} ctx = self.propagator.extract(carrier) self.assertIsNone(ctx) def test_lowercase_headers_are_still_extracted(self): pass def test_default_propagator_options_injected_and_context_is_extracted(self): span_id = "1234" parent_id = "4321" trace_id = "1212" baggage = {"Item1": "Value1", "Item2": "Value2"} carrier = {TRACE_ID: trace_id, SPAN_ID: span_id, PARENT_SPAN_ID: parent_id} for key, value in baggage.items(): carrier[BAGGAGE_PREFIX + key] = value ctx = self.propagator.extract(carrier) self.assertEqual(ctx.span_id, span_id) self.assertEqual(ctx.parent_id, parent_id) self.assertEqual(ctx.trace_id, trace_id) self.assertDictEqual(ctx.baggage, baggage) def test_custom_propagator_options_are_injected_and_context_is_extracted(self): propagator = TextPropagator(PropagatorOpts("X-Trace-ID", "X-Span-ID", "X-Parent-ID", "X-baggage-")) span_id = "1234" parent_id = "4321" trace_id = "1212" carrier = {"X-Span-ID": span_id, "X-Parent-ID": parent_id, "X-Trace-ID": trace_id} baggage = {"Item1": "Value1", "Item2": "Value2"} for key, value in baggage.items(): carrier["X-baggage-" + key] = value ctx = propagator.extract(carrier) self.assertEqual(ctx.span_id, span_id) self.assertEqual(ctx.parent_id, parent_id) self.assertEqual(ctx.trace_id, trace_id) if __name__ == "__main__": unittest.main() haystack-client-python-0.2.2/tests/unit/test_tracer.py000066400000000000000000000045601400365540200231330ustar00rootroot00000000000000import unittest from haystack import HaystackTracer from haystack.recorder import NoopRecorder from haystack.span import SpanContext class HaystackTracerTests(unittest.TestCase): """ Tests haystack specific tracer features. Most of tracer testing is handled in api compatibility checks from opentracing """ def test_common_tags_are_applied_to_new_spans(self): common_tags = {"a": "common_tag", "another": "common_tag"} tracer = HaystackTracer("any_service", NoopRecorder(), common_tags=common_tags) span = tracer.start_span("any_operation") self.assertDictEqual(common_tags, span.tags) def test_common_tags_are_overridden_if_span_specifies_the_same(self): common_tags = {"a": "common_tag", "another": "common_tag"} tracer = HaystackTracer("any_service", NoopRecorder(), common_tags=common_tags) span_tags = {"another": "span_tag"} span = tracer.start_span("any_operation", tags=span_tags) expected_tags = {**common_tags, **span_tags} self.assertDictEqual(expected_tags, span.tags) def test_non_shared_spans_are_created_by_default(self): tracer = HaystackTracer("any_service", NoopRecorder()) trace_id = "123" span_id = "1234" parent_id = "12345" upstream_ctx = SpanContext(trace_id=trace_id, span_id=span_id, parent_id=parent_id) span = tracer.start_span("any_operation", child_of=upstream_ctx) self.assertEqual(span.context.trace_id, trace_id) self.assertNotEqual(span.context.span_id, span_id) self.assertEqual(span.context.parent_id, span_id) def test_shared_spans_are_created_when_enabled(self): tracer = HaystackTracer("any_service", NoopRecorder(), use_shared_spans=True) trace_id = "123" span_id = "1234" parent_id = "12345" upstream_ctx = SpanContext(trace_id=trace_id, span_id=span_id, parent_id=parent_id) span = tracer.start_span("any_operation", child_of=upstream_ctx) self.assertEqual(span.context.trace_id, trace_id) self.assertEqual(span.context.span_id, span_id) self.assertEqual(span.context.parent_id, parent_id) if __name__ == "__main__": unittest.main()