def setup_instrumentation(app):
settings: TracingSettings = _get_settings()
_TRACE_PROVIDER = TracerProvider(
resource=Resource.create({"service.name": settings.jaeger_service})
)
trace.set_tracer_provider(_TRACE_PROVIDER)
if settings.jaeger_hostname: # pragma: no cover
_JAEGER_EXPORTER = JaegerExporter(
agent_host_name=settings.jaeger_hostname,
agent_port=settings.jaeger_port,
)
_TRACE_PROVIDER.add_span_processor(BatchSpanProcessor(_JAEGER_EXPORTER))
AioHttpClientInstrumentor().instrument()
RequestsInstrumentor().instrument()
# Register logging middleware
app.middleware("http")(_log_requests_middleware)
app.middleware("http")(_bind_logger_tracecontext_middleware)
FastAPIInstrumentor.instrument_app(app)
return app
def tracer_provider(
tracer_type: str = Provide[config.tracing.type],
sample_rate: t.Optional[float] = Provide[config.tracing.sample_rate],
zipkin_server_url: t.Optional[str] = Provide[
config.tracing.zipkin.url],
jaeger_server_address: t.Optional[str] = Provide[
config.tracing.jaeger.address],
jaeger_server_port: t.Optional[int] = Provide[
config.tracing.jaeger.port],
):
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from ..utils.telemetry import ParentBasedTraceIdRatio
if sample_rate is None:
sample_rate = 0.0
provider = TracerProvider(
sampler=ParentBasedTraceIdRatio(sample_rate),
# resource: Resource = Resource.create({}),
# shutdown_on_exit: bool = True,
# active_span_processor: Union[
# SynchronousMultiSpanProcessor, ConcurrentMultiSpanProcessor
# ] = None,
# id_generator: IdGenerator = None,
)
if tracer_type == "zipkin" and zipkin_server_url is not None:
from opentelemetry.exporter.zipkin.json import ZipkinExporter
exporter = ZipkinExporter(endpoint=zipkin_server_url, )
provider.add_span_processor(BatchSpanProcessor(exporter))
return provider
elif (tracer_type == "jaeger" and jaeger_server_address is not None
and jaeger_server_port is not None):
from opentelemetry.exporter.jaeger.thrift import JaegerExporter
exporter = JaegerExporter(
agent_host_name=jaeger_server_address,
agent_port=jaeger_server_port,
)
provider.add_span_processor(BatchSpanProcessor(exporter))
return provider
else:
return provider
def setup_jaeger_tracer(env, service, host, port, additional={}):
resource = Resource(attributes={
'service.name': service,
'env': env,
'dd.service': service,
**additional
})
trace.set_tracer_provider(TracerProvider(resource=resource))
trace.get_tracer_provider().get_tracer(__name__)
jaeger_exporter = JaegerExporter(
agent_host_name=host,
agent_port=port,
)
trace.get_tracer_provider().add_span_processor(
SimpleSpanProcessor(jaeger_exporter))
def _get_tracer(jaeger_endpoint: str, service_name: str) -> trace.Tracer:
set_global_textmap(B3MultiFormat())
RequestsInstrumentor().instrument()
trace.set_tracer_provider(
TracerProvider(
resource=Resource.create({SERVICE_NAME: service_name})
)
)
jaeger_exporter = JaegerExporter(
collector_endpoint=jaeger_endpoint + '?format=jaeger.thrift',
)
span_processor = BatchSpanProcessor(jaeger_exporter)
trace.get_tracer_provider().add_span_processor(span_processor)
return trace.get_tracer(__name__)
from opentelemetry.propagate import set_global_textmap
from opentelemetry.propagators.b3 import B3Format
load_dotenv() # take environment variables from .env
# Set global propagator
set_global_textmap(B3Format())
# set trace provider as default one
trace.set_tracer_provider(
TracerProvider(
resource=Resource.create({SERVICE_NAME: "my-helloworld-service"})))
# jaeger exporter
jaeger_exporter = JaegerExporter(
agent_host_name="localhost",
agent_port=6831,
)
# add exporter to trace
trace.get_tracer_provider().add_span_processor(
BatchSpanProcessor(jaeger_exporter)
# SimpleSpanProcessor(ConsoleSpanExporter)
)
app = Flask(__name__)
api = Api(app)
FlaskInstrumentor().instrument_app(app)
RequestsInstrumentor().instrument()
SERVICE_NAME: str = "orchestrator-core"
LOGGING_HOST: str = "localhost"
LOG_LEVEL: str = "DEBUG"
SLACK_ENGINE_SETTINGS_HOOK_ENABLED: bool = False
SLACK_ENGINE_SETTINGS_HOOK_URL: str = ""
TRACING_ENABLED: bool = False
TRANSLATIONS_DIR: Optional[Path] = None
WEBSOCKET_BROADCASTER_URL: str = "memory://"
ENABLE_WEBSOCKETS: bool = True
DISABLE_INSYNC_CHECK: bool = False
DEFAULT_PRODUCT_WORKFLOWS: List[str] = ["modify_note"]
class Oauth2Settings(BaseSettings):
OAUTH2_ACTIVE: bool = False
OAUTH2_RESOURCE_SERVER_ID: str = ""
OAUTH2_RESOURCE_SERVER_SECRET: str = ""
OAUTH2_TOKEN_URL: str = ""
OIDC_CONF_WELL_KNOWN_URL: str = ""
OPA_URL: str = "http://127.0.0.1:8181/v1/data/automation/authorization/allow"
app_settings = AppSettings()
oauth2_settings = Oauth2Settings()
# Tracer settings
tracer_provider = TracerProvider()
jaeger_exporter = JaegerExporter(agent_host_name=app_settings.LOGGING_HOST, udp_split_oversized_batches=True)
tracer_provider.add_span_processor(BatchSpanProcessor(jaeger_exporter))
from opentelemetry.instrumentation.requests import RequestsInstrumentor
from prometheus_client import start_http_server, Counter
service_name = os.environ.get('SERVICE_NAME', 'otel-flask-service')
agent_host = os.environ.get('AGENT_HOST', 'localhost')
agent_port = os.environ.get('AGENT_PORT', '6831')
trace.set_tracer_provider(
TracerProvider(
resource=Resource.create({SERVICE_NAME: service_name})
)
)
jaeger_exporter = JaegerExporter(
agent_host_name = agent_host,
agent_port = int(agent_port),
)
trace.get_tracer_provider().add_span_processor(
BatchSpanProcessor(jaeger_exporter)
)
# Create a metric to track total number of requests made.
REQUEST_TOTAL = Counter('total_requests', 'Total number of HTTP requests')
app = flask.Flask(__name__)
FlaskInstrumentor().instrument_app(app)
RequestsInstrumentor().instrument()
from flask import Flask
from opentelemetry import trace
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
from opentelemetry.instrumentation.flask import FlaskInstrumentor
from opentelemetry.instrumentation.requests import RequestsInstrumentor
from opentelemetry.exporter.jaeger.thrift import JaegerExporter
exporter = ConsoleSpanExporter()
resource = Resource.create({"service.name": "grocery-store"})
provider = TracerProvider(resource=resource)
span_processor = BatchSpanProcessor(exporter)
provider.add_span_processor(span_processor)
provider.add_span_processor(BatchSpanProcessor(JaegerExporter()))
trace.set_tracer_provider(provider)
app = Flask(__name__)
FlaskInstrumentor().instrument_app(app)
RequestsInstrumentor().instrument()
@app.route("/")
def welcome():
with trace.get_tracer(__name__).start_as_current_span("welcome message"):
return "Welcome to the grocery store!"
@app.route("/whats-in-store")
def whats_in_store():
class Model(BaseModel): # hacking for type annotation
...
else:
Model = db.Model
tracer = trace.get_tracer(__name__)
# pytest no need to check
if not setting.ENV == "TEST":
use_console_exporter = True
if use_console_exporter:
span_processor = BatchSpanProcessor(ConsoleSpanExporter())
else:
jaeger_exporter = JaegerExporter(
agent_host_name="jaeger",
agent_port=6831,
)
span_processor = BatchSpanProcessor(jaeger_exporter)
trace.set_tracer_provider(
TracerProvider(resource=Resource.create({SERVICE_NAME: "tifa"})))
provider = trace.get_tracer_provider()
provider.add_span_processor(span_processor)
celery = Celery()
celery.conf.broker_url = setting.REDIS_CELERY_URL
celery.conf.timezone = "Asia/Shanghai"
from opentelemetry import trace
from opentelemetry.exporter.jaeger.thrift import JaegerExporter
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
trace.set_tracer_provider(
TracerProvider(resource=Resource.create(
{"service.name": "example_exporter"}), ), )
# Configurando o agente do jeager
# From https://opentelemetry-python.readthedocs.io/en/latest/exporter/jaeger/jaeger.html
jaeger_exporter = JaegerExporter(
agent_host_name='jaeger',
agent_port=6831,
)
# Criando um span e vinculando a um BatchSpanProcessor para envio ao Jeager
# https://opentelemetry-python.readthedocs.io/en/stable/sdk/trace.export.html?highlight=BatchSpanProcessor#opentelemetry.sdk.trace.export.BatchSpanProcessor
span_processor = BatchSpanProcessor(jaeger_exporter)
# Neste exemplo adicionamos o dados de telemetria ao tracer a partir do batch declarado acima:
trace.get_tracer_provider().add_span_processor(span_processor)
tracer = trace.get_tracer(__name__)
with tracer.start_as_current_span("teste_com_span"):
print("SRE and DevOps work together!!!")
from opentelemetry import trace
from opentelemetry.exporter.jaeger.thrift import JaegerExporter
from opentelemetry.instrumentation.celery import CeleryInstrumentor
from opentelemetry.instrumentation.logging import LoggingInstrumentor
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from pysnmp.carrier.asyncio.dgram import udp
from pysnmp.entity import config, engine
from pysnmp.entity.rfc3413 import ntfrcv
from splunk_connect_for_snmp.snmp.const import AuthProtocolMap, PrivProtocolMap
from splunk_connect_for_snmp.snmp.tasks import trap
from splunk_connect_for_snmp.splunk.tasks import prepare, send
provider = TracerProvider()
processor = BatchSpanProcessor(JaegerExporter())
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)
CONFIG_PATH = os.getenv("CONFIG_PATH", "/app/config/config.yaml")
SECURITY_ENGINE_ID = os.getenv("SNMP_V3_SECURITY_ENGINE_ID",
"8000000903000A397056B8AC")
LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")
logging.basicConfig(level=getattr(logging, LOG_LEVEL),
format="%(asctime)s %(levelname)s %(message)s")
formatter = CustomisedJSONFormatter()
# //using rabbitmq as the message broker
app = Celery("sc4snmp_traps")
app.config_from_object("splunk_connect_for_snmp.celery_config")
from aiohttp import web
import aiopg
from opentelemetry import trace
from opentelemetry.exporter.jaeger.thrift import JaegerExporter
from opentelemetry.sdk.resources import SERVICE_NAME, Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.instrumentation.aiopg import AiopgInstrumentor
trace_provider = TracerProvider(
resource=Resource.create({SERVICE_NAME: "my-service"}))
trace.set_tracer_provider(trace_provider)
tracer = trace.get_tracer(__name__)
jaeger_exporter = JaegerExporter(agent_host_name="127.0.0.1", agent_port=5775)
span_processor = BatchSpanProcessor(jaeger_exporter)
trace.get_tracer_provider().add_span_processor(span_processor)
AiopgInstrumentor().instrument()
dsn = "dbname=test user=postgres password=postgres host=127.0.0.1"
async def init_pg(app):
pool = await aiopg.create_pool(dsn)
app["pool"] = pool
async def handle(request):
from opentelemetry.sdk.resources import SERVICE_NAME, Resource
from opentelemetry.instrumentation.flask import FlaskInstrumentor
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
app = Flask(__name__)
trace.set_tracer_provider(
TracerProvider(resource=Resource.create({
SERVICE_NAME:
os.getenv('OTEL_JAEGER_SERVICE_NAME', "python-service")
})))
tracer = trace.get_tracer(__name__)
# SpanExporter receives the spans and send them to the target location.
exporter = JaegerExporter(agent_host_name=os.getenv('OTEL_JAEGER_AGENT_HOST',
"localhost"),
agent_port=6831)
span_processor = BatchSpanProcessor(exporter)
trace.get_tracer_provider().add_span_processor(span_processor)
FlaskInstrumentor().instrument_app(app)
MySQLInstrumentor().instrument()
# configuration used to connect to MariaDB
config = {
'host': os.getenv('MYSQL_HOST', "localhost"),
'port': 3306,
'user': os.getenv('MYSQL_USER', "admin"),
'password': os.getenv('MYSQL_PASSWORD', "password"),
'database': 'salary_amount'
