def setup_tracer(service_name): jaeger_exporter = jaeger.JaegerSpanExporter( service_name=service_name, # configure agent agent_host_name='jaeger', agent_port=6831, ) span_processor = BatchExportSpanProcessor(jaeger_exporter) trace.set_preferred_tracer_source_implementation(lambda T: TracerSource()) trace.tracer_source().add_span_processor(span_processor) postgres_tracer = trace.tracer_source().get_tracer('postgres') trace_integration(postgres_tracer)
def test_constructor_default(self): """Test the default values assigned by constructor.""" service_name = "my-service-name" host_name = "localhost" thrift_port = None agent_port = 6831 collector_endpoint = "/api/traces?format=jaeger.thrift" exporter = jaeger_exporter.JaegerSpanExporter(service_name) self.assertEqual(exporter.service_name, service_name) self.assertEqual(exporter.collector_host_name, None) self.assertEqual(exporter.agent_host_name, host_name) self.assertEqual(exporter.agent_port, agent_port) self.assertEqual(exporter.collector_port, thrift_port) self.assertEqual(exporter.collector_endpoint, collector_endpoint) self.assertEqual(exporter.username, None) self.assertEqual(exporter.password, None) self.assertTrue(exporter.collector is None) self.assertTrue(exporter.agent_client is not None)
def test_constructor_explicit(self): """Test the constructor passing all the options.""" service = "my-opentelemetry-jaeger" collector_host_name = "opentelemetry.io" collector_port = 15875 collector_endpoint = "/myapi/traces?format=jaeger.thrift" agent_port = 14268 agent_host_name = "opentelemetry.io" username = "******" password = "******" auth = (username, password) exporter = jaeger_exporter.JaegerSpanExporter( service_name=service, collector_host_name=collector_host_name, collector_port=collector_port, collector_endpoint=collector_endpoint, agent_host_name=agent_host_name, agent_port=agent_port, username=username, password=password, ) self.assertEqual(exporter.service_name, service) self.assertEqual(exporter.agent_host_name, agent_host_name) self.assertEqual(exporter.agent_port, agent_port) self.assertEqual(exporter.collector_host_name, collector_host_name) self.assertEqual(exporter.collector_port, collector_port) self.assertTrue(exporter.collector is not None) self.assertEqual(exporter.collector.auth, auth) # property should not construct new object collector = exporter.collector self.assertEqual(exporter.collector, collector) # property should construct new object # pylint: disable=protected-access exporter._collector = None exporter.username = None exporter.password = None self.assertNotEqual(exporter.collector, collector) self.assertTrue(exporter.collector.auth is None)
def test_export(self): """Test that agent and/or collector are invoked""" exporter = jaeger_exporter.JaegerSpanExporter( "test_export", agent_host_name="localhost", agent_port=6318) # just agent is configured now agent_client_mock = mock.Mock(spec=jaeger_exporter.AgentClientUDP) # pylint: disable=protected-access exporter._agent_client = agent_client_mock exporter.export((self._test_span, )) self.assertEqual(agent_client_mock.emit.call_count, 1) # add also a collector and test that both are called collector_mock = mock.Mock(spec=jaeger_exporter.Collector) # pylint: disable=protected-access exporter._collector = collector_mock exporter.export((self._test_span, )) self.assertEqual(agent_client_mock.emit.call_count, 2) self.assertEqual(collector_mock.submit.call_count, 1)
def init_jaeger(jaeger_host: str, service_name): trace.set_tracer_provider(TracerProvider()) tracer = trace.get_tracer_provider().get_tracer(__name__) # trace.get_tracer_provider().add_span_processor( # BatchExportSpanProcessor(ConsoleSpanExporter()) # ) # create a JaegerSpanExporter jaeger_exporter = jaeger.JaegerSpanExporter( service_name=service_name, # configure agent agent_host_name=jaeger_host, agent_port=6831, # optional: configure also collector # collector_host_name='localhost', # collector_port=14268, # collector_endpoint='/api/traces?format=jaeger.thrift', # username=xxxx, # optional # password=xxxx, # optional ) # Create a BatchExportSpanProcessor and add the exporter to it span_processor = BatchExportSpanProcessor(jaeger_exporter) # add to the tracer trace.get_tracer_provider().add_span_processor(span_processor) return tracer
def direct_message_consume(messaging_service: MessagingService, topic_subscription: str): try: trace.set_tracer_provider(TracerProvider()) jaeger_exporter = jaeger.JaegerSpanExporter( service_name="<Solace> REST Messaging call to Security Co", agent_host_name="localhost", agent_port=6831, ) trace.get_tracer_provider().add_span_processor( BatchExportSpanProcessor(jaeger_exporter)) tracer = trace.get_tracer(__name__) topics = [TopicSubscription.of(topic_subscription)] # Create a direct message consumer service with the topic subscription and start it direct_receive_service = messaging_service.create_direct_message_receiver_builder( ) direct_receive_service = direct_receive_service.with_subscriptions( topics).build() direct_receive_service.start() # Register a callback message handler direct_receive_service.receive_async(MessageHandlerImpl()) print(f"Subscribed to: {topic_subscription}") # Infinite loop until Keyboard interrupt is received try: while True: time.sleep(1) except KeyboardInterrupt: print('\nDisconnecting Messaging Service') finally: messaging_service.disconnect() direct_receive_service.terminate()
# Publish the message! direct_publish_service.publish(destination=topic, message=message) finally: direct_publish_service.terminate() outboundTopic = "opentelemetry/helloworld" broker_props = {"solace.messaging.transport.host": os.environ['SOLACE_HOST'], "solace.messaging.service.vpn-name": os.environ['SOLACE_VPN'], "solace.messaging.authentication.scheme.basic.username": os.environ['SOLACE_USERNAME'], "solace.messaging.authentication.scheme.basic.password": os.environ['SOLACE_PASSWORD']} trace.set_tracer_provider(TracerProvider()) jaeger_exporter = jaeger.JaegerSpanExporter( service_name="<Boomi> Listen for Salesforce Platform Account, publish Solace DriverUpserted", agent_host_name="localhost", agent_port=6831, ) trace.get_tracer_provider().add_span_processor( BatchExportSpanProcessor(jaeger_exporter) ) tracer = trace.get_tracer(__name__) # THIS IS PER https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/trace/semantic_conventions/messaging.md parentSpan = tracer.start_span( "RideUpdated send", kind=SpanKind.PRODUCER, attributes={ "messaging.system": "solace", "messaging.destination": outboundTopic,
app = flask.Flask(__name__) FlaskInstrumentor().instrument_app(app) opentelemetry.ext.requests.RequestsInstrumentor().instrument() ''' #-------------------------------------------------------------- trace.set_tracer_provider(TracerProvider()) tracer = trace.get_tracer(__name__) # create a JaegerSpanExporter jaeger_exporter = jaeger.JaegerSpanExporter( service_name="TracedService2", agent_host_name="simplest-agent.observability.svc.cluster.local", # agent_host_name="jaeger-agent.observability.svc.cluster.local", agent_port=6831, # optional: configure also collector # collector_host_name='localhost', # collector_port=14268, # collector_endpoint='/api/traces?format=jaeger.thrift', # username=xxxx, # optional # password=xxxx, # optional ) # Create a BatchExportSpanProcessor and add the exporter to it span_processor = BatchExportSpanProcessor(jaeger_exporter) # add to the tracer trace.get_tracer_provider().add_span_processor(span_processor) app = flask.Flask(__name__) app.wsgi_app = OpenTelemetryMiddleware(app.wsgi_app) #wsgi
from opentelemetry import trace from opentelemetry.ext import jaeger from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import ConsoleSpanExporter from opentelemetry.sdk.trace.export import SimpleExportSpanProcessor from opentelemetry.ext.flask import FlaskInstrumentor from nats.aio.client import Client as NATS myclient = pymongo.MongoClient("mongodb://10.128.0.3:27017/") mydb = myclient["proyecto"] mycol = mydb["infectados"] r = redis.Redis(host='10.128.0.3', port=6379, password='', db='15') jaeger_exporter = jaeger.JaegerSpanExporter( service_name="my-traced-service", agent_host_name="simplest-agent.proyecto.svc.cluster.local", agent_port=6831) trace.set_tracer_provider(TracerProvider()) trace.get_tracer_provider().add_span_processor( SimpleExportSpanProcessor(jaeger_exporter)) async def run(loop): nc = NATS() async def closed_cb(): print("Connection to NATS is closed.") await asyncio.sleep(0.1, loop=loop) loop.stop()
from opentelemetry.sdk.trace import TracerSource from opentelemetry.sdk.trace.export import ConsoleSpanExporter from opentelemetry.sdk.trace.export import SimpleExportSpanProcessor from opentelemetry.sdk.trace.export import BatchExportSpanProcessor trace.set_preferred_tracer_source_implementation(lambda T: TracerSource()) trace.tracer_source().add_span_processor( SimpleExportSpanProcessor(ConsoleSpanExporter()) ) tracer = trace.tracer_source().get_tracer(__name__) # create a JaegerSpanExporter jaeger_exporter = jaeger.JaegerSpanExporter( service_name='zoogle', # configure agent agent_host_name='jaeger', agent_port=6831, # optional: configure also collector collector_host_name='jaeger', collector_port=14268, collector_endpoint='/api/traces?format=jaeger.thrift', # username=xxxx, # optional # password=xxxx, # optional ) # Create a BatchExportSpanProcessor and add the exporter to it span_processor = BatchExportSpanProcessor(jaeger_exporter) # add to the tracer tracer.add_span_processor(span_processor)
from twilio.twiml.messaging_response import MessagingResponse import requests import opentelemetry.ext.requests from opentelemetry import trace from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import ConsoleSpanExporter from opentelemetry.sdk.trace.export import SimpleExportSpanProcessor from opentelemetry.ext.flask import FlaskInstrumentor from opentelemetry.ext import jaeger trace.set_tracer_provider(TracerProvider()) jaeger_exporter = jaeger.JaegerSpanExporter(service_name="BookWorm-service", agent_host_name="localhost", agent_port=6831) trace.get_tracer_provider().add_span_processor( SimpleExportSpanProcessor(jaeger_exporter)) app = Flask(__name__) FlaskInstrumentor().instrument_app(app) @app.route('/sms', methods=['POST']) def sms(): tracer = trace.get_tracer(__name__) with tracer.start_as_current_span("example-request"): resp = MessagingResponse() #hey = MessagingResponse()
from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import BatchExportSpanProcessor import uvicorn trace.set_tracer_provider(TracerProvider()) tracer = trace.get_tracer(__name__) # create a JaegerSpanExporter jaeger_exporter = jaeger.JaegerSpanExporter( service_name='fastapi_opentelemetry', # configure agent # agent_host_name='localhost', agent_host_name='84.201.149.110', agent_port=6831, # optional: configure also collector # collector_host_name='localhost', # collector_port=14268, # collector_endpoint='/api/traces?format=jaeger.thrift', # username=xxxx, # optional # password=xxxx, # optional ) # Create a BatchExportSpanProcessor and add the exporter to it span_processor = BatchExportSpanProcessor(jaeger_exporter) # add to the tracer trace.get_tracer_provider().add_span_processor(span_processor) app = FastAPI() FastAPIInstrumentor.instrument_app(app)
from opentelemetry import trace from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import ( ConsoleSpanExporter, SimpleExportSpanProcessor, ) from opentelemetry.ext import jaeger app = Flask(__name__) trace.set_tracer_provider(TracerProvider()) trace.get_tracer_provider().add_span_processor( SimpleExportSpanProcessor(ConsoleSpanExporter())) service_name = "test_instrumentation_server" jaeger_exporter = jaeger.JaegerSpanExporter(service_name=f"{service_name}", agent_host_name="localhost", agent_port=6831) @app.route("/server_request") def server_request(): print(request.args.get("param")) return "served" if __name__ == "__main__": app.run(port=8082)
#tracing simple import flask import requests import opentelemetry.ext.requests from opentelemetry import trace from opentelemetry.ext import jaeger from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import ConsoleSpanExporter from opentelemetry.sdk.trace.export import SimpleExportSpanProcessor from opentelemetry.ext.flask import FlaskInstrumentor jaeger_exporter = jaeger.JaegerSpanExporter( service_name="my-helloworld-service", agent_host_name="simplest-agent.observability.svc.cluster.local", agent_port=6831) trace.set_tracer_provider(TracerProvider()) trace.get_tracer_provider().add_span_processor( SimpleExportSpanProcessor(jaeger_exporter)) app = flask.Flask(__name__) FlaskInstrumentor().instrument_app(app) opentelemetry.ext.requests.RequestsInstrumentor().instrument() @app.route("/") def hello(): tracer = trace.get_tracer(__name__) with tracer.start_as_current_span("example-request"): requests.get("http://www.example.com")
"aerospace", "machinery", "finance", "strategy", "beer", "coffee", "whisky", "laundry", "socks", ] # Initialize tracing. trace.set_tracer_provider(TracerProvider()) jaeger_exporter = jaeger.JaegerSpanExporter( service_name="field", agent_host_name="jaeger", agent_port=6831, ) span_processor = BatchExportSpanProcessor(jaeger_exporter) trace.get_tracer_provider().add_span_processor(span_processor) tracer = trace.get_tracer(__name__) class Field(field_pb2_grpc.FieldServicer): def GetField(self, request, context): log = logging.getLogger() log.info('Received field request') # Get current span. The span was created within the gRPC interceptor. # We are retrieving it here because we want to add data to it. span = tracer.get_current_span()
import flask import requests import opentelemetry.ext.requests from opentelemetry import trace from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import ConsoleSpanExporter from opentelemetry.sdk.trace.export import SimpleExportSpanProcessor from opentelemetry.ext.flask import FlaskInstrumentor from opentelemetry.ext import jaeger trace.set_tracer_provider(TracerProvider()) jaeger_exporter = jaeger.JaegerSpanExporter(service_name="my-flask-service", agent_host_name="localhost", agent_port=6831) trace.get_tracer_provider().add_span_processor( SimpleExportSpanProcessor(jaeger_exporter)) app = flask.Flask(__name__) FlaskInstrumentor().instrument_app(app) # opentelemetry.ext.http_requests.RequestsInstrumentor().instrument() opentelemetry.ext.requests.RequestsInstrumentor().instrument() @app.route("/") def hello(): tracer = trace.get_tracer(__name__) with tracer.start_as_current_span("example-request"): requests.get("http://www.example.com") return "hello"
from opentelemetry import trace from opentelemetry.ext import jaeger from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import BatchExportSpanProcessor trace.set_preferred_tracer_provider_implementation(lambda T: TracerProvider()) tracer = trace.get_tracer(__name__) # create a JaegerSpanExporter jaeger_exporter = jaeger.JaegerSpanExporter( service_name="my-helloworld-service", # configure agent agent_host_name="localhost", agent_port=6831, # optional: configure also collector # collector_host_name="localhost", # collector_port=14268, # collector_endpoint="/api/traces?format=jaeger.thrift", # username=xxxx, # optional # password=xxxx, # optional ) # create a BatchExportSpanProcessor and add the exporter to it span_processor = BatchExportSpanProcessor(jaeger_exporter) # add to the tracer factory trace.tracer_provider().add_span_processor(span_processor) # create some spans for testing with tracer.start_as_current_span("foo") as foo: time.sleep(0.1)
# # 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. # jaeger_example.py from opentelemetry import trace from opentelemetry.ext import jaeger from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import BatchExportSpanProcessor trace.set_tracer_provider(TracerProvider()) jaeger_exporter = jaeger.JaegerSpanExporter( service_name="my-helloworld-service", agent_host_name="localhost", agent_port=6831, ) trace.get_tracer_provider().add_span_processor( BatchExportSpanProcessor(jaeger_exporter)) tracer = trace.get_tracer(__name__) with tracer.start_as_current_span("foo"): with tracer.start_as_current_span("bar"): with tracer.start_as_current_span("baz"): print("Hello world from OpenTelemetry Python!")
cfg = utils.init_env_and_logger() logger = cfg['logger'] logging.getLogger('').handlers = [] logging.basicConfig(format='%(message)s', level=logging.DEBUG) app = FastAPI() FastAPIInstrumentor.instrument_app(app) # Добавить реализцию для OpenTracing Shim for OpenTelemetry # Tell OpenTelemetry which Tracer implementation to use. trace.set_tracer_provider(TracerProvider()) jaeger_exporter = jaeger.JaegerSpanExporter( service_name=f"{service_name}_opentelemetry", agent_host_name="192.168.10.127", agent_port=6831) trace.get_tracer_provider().add_span_processor( SimpleExportSpanProcessor(jaeger_exporter)) # Create an OpenTelemetry Tracer. # otel_tracer = trace.get_tracer(service_name) # Create an OpenTracing shim. # shim = create_tracer(otel_tracer) shim = create_tracer(trace.get_tracer_provider()) # ========= # Добавить реализцию для opentracing opentracing_config = jaeger_config(