def tearDown(self):
# pylint: disable=invalid-name
# clear the database and dispose the engine
self.session.close()
Base.metadata.drop_all(bind=self.engine)
self.engine.dispose()
SQLAlchemyInstrumentor().uninstrument()
super().tearDown()
def test_create_engine_wrapper(self):
SQLAlchemyInstrumentor().instrument()
from sqlalchemy import create_engine # pylint: disable-all
engine = create_engine("sqlite:///:memory:")
cnx = engine.connect()
cnx.execute("SELECT 1 + 1;").fetchall()
spans = self.memory_exporter.get_finished_spans()
self.assertEqual(len(spans), 1)
self.assertEqual(spans[0].name, "sqlite.query")
def setUp(self):
# create a traced engine with the given arguments
SQLAlchemyInstrumentor().instrument()
dsn = (
"postgresql://%(user)s:%(password)s@%(host)s:%(port)s/%(dbname)s"
% POSTGRES_CONFIG
)
self.engine = sqlalchemy.create_engine(dsn)
# prepare a connection
self.conn = self.engine.connect()
super().setUp()
def test_trace_integration(self):
engine = create_engine("sqlite:///:memory:")
SQLAlchemyInstrumentor().instrument(
engine=engine,
tracer_provider=self.tracer_provider,
service="my-database",
)
cnx = engine.connect()
cnx.execute("SELECT 1 + 1;").fetchall()
spans = self.memory_exporter.get_finished_spans()
self.assertEqual(len(spans), 1)
self.assertEqual(spans[0].name, "sqlite.query")
def setUp(self):
super().setUp()
# create an engine with the given arguments
self.engine = _create_engine(self.ENGINE_ARGS)
# create the database / entities and prepare a session for the test
Base.metadata.drop_all(bind=self.engine)
Base.metadata.create_all(self.engine, checkfirst=False)
self.session = sessionmaker(bind=self.engine)()
# trace the engine
SQLAlchemyInstrumentor().instrument(
engine=self.engine, tracer_provider=self.tracer_provider)
self.memory_exporter.clear()
def __init__(self, uri, logger=logging):
self.engine = create_engine(uri)
self.logger = logger
self.contacts_table = Table(
"contacts",
MetaData(self.engine),
Column("username", String, nullable=False),
Column("label", String, nullable=False),
Column("account_num", String, nullable=False),
Column("routing_num", String, nullable=False),
Column("is_external", Boolean, nullable=False),
)
# Set up tracing autoinstrumentation for sqlalchemy
SQLAlchemyInstrumentor().instrument(
engine=self.engine,
service="contacts",
)
def __init__(self, uri, logger=logging):
self.engine = create_engine(uri)
self.logger = logger
self.users_table = Table(
'users',
MetaData(self.engine),
Column('accountid', String, primary_key=True),
Column('username', String, unique=True, nullable=False),
Column('passhash', LargeBinary, nullable=False),
Column('firstname', String, nullable=False),
Column('lastname', String, nullable=False),
Column('birthday', Date, nullable=False),
Column('timezone', String, nullable=False),
Column('address', String, nullable=False),
Column('state', String, nullable=False),
Column('zip', String, nullable=False),
Column('ssn', String, nullable=False),
)
# Set up tracing autoinstrumentation for sqlalchemy
SQLAlchemyInstrumentor().instrument(
engine=self.engine,
service='users',
)
def tearDown(self):
super().tearDown()
SQLAlchemyInstrumentor().uninstrument()
def tearDown(self):
# clear the database and dispose the engine
self.conn.close()
self.engine.dispose()
SQLAlchemyInstrumentor().uninstrument()
from opentelemetry.ext.sqlalchemy import SQLAlchemyInstrumentor
from opentelemetry.ext.requests import RequestsInstrumentor
from opentelemetry.sdk.metrics import Counter, MeterProvider
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchExportSpanProcessor
app = Flask(__name__)
app.config.from_object(Config)
db = SQLAlchemy(app)
# Set global TracerProvider before instrumenting
trace.set_tracer_provider(TracerProvider())
# Enable tracing for sqlalchemy library
SQLAlchemyInstrumentor().instrument()
# Enable tracing for Flask library
FlaskInstrumentor().instrument_app(app)
# Enable tracing for requests library
RequestsInstrumentor().instrument()
trace_exporter = AzureMonitorSpanExporter(
connection_string=Config.CONNECTION_STRING
)
trace.get_tracer_provider().add_span_processor(
BatchExportSpanProcessor(trace_exporter)
)
# Set global MeterProvider before recording
class Service(BaseModel):
id: int
name: str
stage: str
host: str
port: int
active: bool
session, service_table, engine, database = init_db(DB_HOST, cfg["base_name"],
DB_USER, DB_PASS,
cfg["table_name"])
SQLAlchemyInstrumentor().instrument(
engine=engine,
service=service_name,
)
@app.on_event("startup")
async def startup():
await database.connect()
@app.on_event("shutdown")
async def shutdown():
await database.disconnect()
@app.post("/login", response_model=Token)
async def login_for_access_token(