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(
