def get_application() -> FastAPI: application = FastAPI(title="Haystack-API", debug=True, version="0.1") origins = [ "https://entroprise.com", "https://www.entroprise.com", "https://app.entroprise.com" "https://hasura.entroprise.com", "http://entroprise.com", "http://www.entroprise.com", "http://app.entroprise.com", "http://hasura.entroprise.com", "http://localhost", "http://localhost:3000", "http://127.0.0.1", "http://127.0.0.1:3000", ] application.add_middleware( CORSMiddleware, allow_origin_regex='https?://.*', allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) if APM_SERVER: apm_config = {"SERVICE_NAME": APM_SERVICE_NAME, "SERVER_URL": APM_SERVER, "CAPTURE_BODY": "all"} elasticapm = make_apm_client(apm_config) application.add_middleware(ElasticAPM, client=elasticapm) application.add_exception_handler(HTTPException, http_error_handler) application.include_router(api_router) return application
def get_application() -> FastAPI: application = FastAPI(title="Haystack-API", debug=True, version="0.1") application.add_middleware( CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) if APM_SERVER: apm_config = { "SERVICE_NAME": APM_SERVICE_NAME, "SERVER_URL": APM_SERVER, "CAPTURE_BODY": "all" } elasticapm = make_apm_client(apm_config) application.add_middleware(ElasticAPM, client=elasticapm) application.add_exception_handler(HTTPException, http_error_handler) application.include_router(api_router) return application
def initiate_apm_client(): logger.debug(f'apm_enable: {Utility.environment["elasticsearch"].get("enable")}') if Utility.environment["elasticsearch"].get("enable"): server_url = Utility.environment["elasticsearch"].get("apm_server_url") service_name = Utility.environment["elasticsearch"].get("service_name") env = Utility.environment["elasticsearch"].get("env_type") request = {"SERVER_URL": server_url, "SERVICE_NAME": service_name, 'ENVIRONMENT': env, } if Utility.environment["elasticsearch"].get("secret_token"): request['SECRET_TOKEN'] = Utility.environment["elasticsearch"].get("secret_token") logger.debug(f'apm: {request}') if service_name and server_url: apm = make_apm_client(request) return apm
def get_application() -> FastAPI: application = FastAPI(title="Haystack API", debug=True, version="0.1") application.add_middleware( CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) apm_config = {"SERVICE_NAME": "covid-backend", "SERVER_URL": APM_SERVER} elasticapm = make_apm_client(apm_config) application.add_middleware(ElasticAPM, client=elasticapm) application.add_exception_handler(HTTPException, http_error_handler) # application.add_event_handler("startup", create_start_app_handler(application)) # application.add_event_handler("shutdown", create_stop_app_handler(application)) application.include_router(api_router) return application
# Licensed to Elasticsearch B.V under one or more agreements. # Elasticsearch B.V licenses this file to you under the Apache 2.0 License. # See the LICENSE file in the project root for more information import aiohttp import datetime import os from fastapi import FastAPI from fastapi.encoders import jsonable_encoder from elasticsearch import AsyncElasticsearch, NotFoundError from elasticsearch.helpers import async_streaming_bulk from elasticapm.contrib.starlette import ElasticAPM, make_apm_client apm = make_apm_client({ "SERVICE_NAME": "fastapi-app", "SERVER_URL": "http://*****:*****@app.on_event("shutdown") async def app_shutdown(): await es.close() @app.post('/create') async def create_user(user): if not (await es.indices.exists(index="users")): await es.indices.create(index="users")
from fastapi import FastAPI from fastapi.responses import PlainTextResponse, HTMLResponse from elasticapm.contrib.starlette import make_apm_client, ElasticAPM from .items import Items from .meli import Meli from .models.item import Item from .models.domain import Domain from .models.ft import FT apm = make_apm_client({ "SERVICE_NAME": "probema-ft-api", "DEBUG": True, "SERVER_URL": "http://apm:8200", "CAPTURE_HEADERS": True, "CAPTURE_BODY": "all", }) app = FastAPI( title="Problema FT", description="Solución de problema FT", version="0.0.1", openapi_url="/api/openapi.json", docs_url="/api/docs", redoc_url="/api/redoc", ) app.add_middleware(ElasticAPM, client=apm) meli = Meli() items = Items()
from uuid import uuid4 from elasticapm.contrib.starlette import make_apm_client, ElasticAPM from fastapi import FastAPI, Request from src.endpoints import health_check from src.endpoints.v1 import utters from src.settings import BASE_PATH, ELASTIC_APM, ENABLE_MONITORING from src.database.connection import database app = FastAPI() if ENABLE_MONITORING: app.add_middleware(ElasticAPM, client=make_apm_client(ELASTIC_APM)) @app.on_event("startup") async def startup(): await database.connect() @app.on_event("shutdown") async def shutdown(): await database.disconnect() @app.middleware("http") async def default_handler(request: Request, call_next): request.state.transaction_id = str(uuid4()) response = await call_next(request) return response
logger.addHandler(logstash.LogstashHandler(host, port, version=1)) # Create the fastapi app app = FastAPI() # Creating the fastapi apm middleware # https://www.elastic.co/guide/en/apm/agent/python/master/starlette-support.html settings = { 'SERVER_URL': os.environ.get('APM_SERVER_URL'), 'SERVICE_NAME': os.environ.get('APM_SEVICE_NAME'), 'SECRET_TOKEN': os.environ.get('APM_SECRET_TOKEN'), 'CAPTURE_BODY': 'all', 'CAPTURE_HEADERS': True, 'DEBUG': True, } # Just for demo apm_client = make_apm_client(settings) app.add_middleware(ElasticAPM, client=apm_client) # Below is a fast API example app # https://fastapi.tiangolo.com/ class Purchase(BaseModel): username: str email: str = None cost_spend: float = None item_count: int = None class Billing(Purchase): id: str billing_amount: float
from fastapi import FastAPI from fastapi.responses import FileResponse from fpdf import FPDF from elasticapm.contrib.starlette import make_apm_client, ElasticAPM import json import logger import requests ## --- init log = logger.getLogger("api") elasticapm = make_apm_client({}) app = FastAPI() app.add_middleware(ElasticAPM, client=elasticapm) class PDF(FPDF): REPORT_FULLNAME = "/home/reports/todos.pdf" def header(self): self.set_font('Arial', 'B', 20) self.set_fill_color(200, 220, 255) self.cell(0, 15, 'List of Todos', 1, 0, 'C', 1) self.ln(30) def footer(self): self.set_y(-15) self.set_font('Arial', 'I', 8) self.cell(0, 10, 'Page ' + str(self.page_no()) + '/{nb}', 0, 0, 'C') def save(self): self.output(self.REPORT_FULLNAME)
logging.getLogger().handlers = [config.InterceptHandler()] logging.getLogger("uvicorn.access").handlers = [config.InterceptHandler()] logger.configure(handlers=[{"sink": sys.stderr, "level": config.settings.log_level}]) logger.info( "___________________ STARTING STACKL API SERVER ____________________") # Add routes app = FastAPI(title="STACKL", description="stackl", version=metadata.version('core')) if config.settings.elastic_apm_enabled: logger.debug("Elastic APM Enabled") apm = make_apm_client(config={}) app.add_middleware(ElasticAPM, client=apm) app.include_router(infrastructure_base_router.router, prefix="/infrastructure_base", tags=["infrastructure_base"]) app.include_router(policy_templates_router.router, prefix="/policy_templates", tags=["policy_templates"]) app.include_router(snapshots_router.router, prefix="/snapshots", tags=["snapshots"]) app.include_router(stack_instances_router.router, prefix="/stack_instances", tags=["stack_instances"]) app.include_router(functional_requirements_router.router,
from elasticapm.contrib.starlette import make_apm_client from fastapi import APIRouter, Depends, File, UploadFile, HTTPException from prometheus_client import Summary from app.api import db from app.api.auth import authorize from app.api.models import CategoryIn, CategoryOut, CategoryUpdate categories = APIRouter() request_metrics = Summary('request_processing_seconds', 'Time spent processing request') apm = make_apm_client({ 'SERVICE_NAME': 'Categories', 'SERVER_URL': getenv('APM_URL') }) def raise_404_if_none(func): @wraps(func) async def wrapper(*args, **kwargs): result = await func(*args, **kwargs) if not result: raise HTTPException(status_code=404, detail='Category not found.') return result return wrapper @request_metrics.time()
def test_make_client_without_config(): with mock.patch.dict("os.environ", {"ELASTIC_APM_SERVICE_NAME": "foo"}): c = make_apm_client(client_cls=TempStoreClient) c.close() assert c.config.service_name == "foo"
def test_make_client_with_config(): c = make_apm_client(config={"SERVICE_NAME": "foo"}, client_cls=TempStoreClient) c.close() assert c.config.service_name == "foo"
import os import secrets from elasticapm.contrib.starlette import ElasticAPM, make_apm_client from fastapi import FastAPI, Depends, HTTPException from fastapi.security import HTTPBasic, HTTPBasicCredentials from starlette.responses import Response basic_security = HTTPBasic() app = FastAPI(openapi_url=None) apm = make_apm_client({ 'SERVICE_NAME': 'Auth', 'SERVER_URL': os.getenv('APM_URL') }) app.add_middleware(ElasticAPM, client=apm) def get_variable(name: str) -> str: path = os.getenv(name) with open(path, 'r') as f: return f.readline().rstrip('\n') @app.get('/api/auth/basic', status_code=204, response_class=Response) def auth(credentials: HTTPBasicCredentials = Depends(basic_security)): is_user_ok = secrets.compare_digest(credentials.username, get_variable('LOGIN')) is_pass_ok = secrets.compare_digest(credentials.password, get_variable('PASSWORD'))
from os import getenv from typing import List from elasticapm.contrib.starlette import make_apm_client from fastapi import APIRouter, Depends, HTTPException from prometheus_client import Summary from app.api import db from app.api.auth import authorize from app.api.models import ProductIn, ProductOut, ProductUpdate, ProductSearch products = APIRouter() request_metrics = Summary('request_processing_seconds', 'Time spent processing request') apm = make_apm_client({'SERVICE_NAME': 'Products', 'SERVER_URL': getenv('APM_URL')}) def raise_404_if_none(func): @wraps(func) async def wrapper(*args, **kwargs): result = await func(*args, **kwargs) if not result: raise HTTPException(status_code=404, detail='Product not found.') return result return wrapper @request_metrics.time() @products.get('/{product_id}', response_model=ProductOut)
allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) # Executa se o serviço de APM foi informado nas variáveis de ambiente if APM_SERVICE_NAME != '': apm_config = { "SERVICE_NAME": APM_SERVICE_NAME, "SERVER_URL": APM_SERVICE_URL, "ENVIROMENT": ENVIROMENT, "ENABLED": True, "LOG_LEVEL": "trace", "LOG_FILE_SIZE": "200mb" } elasticapm = make_apm_client(apm_config) # inicializa o agente app.add_middleware(ElasticAPM, client=elasticapm) @app.on_event("startup") async def startup_event(): print('Start') @app.on_event("shutdown") async def shutdown_event(): print('Shutdown')
from fastapi import FastAPI from typing import List # ネストされたBodyを定義するために必要 from starlette.middleware.cors import CORSMiddleware # CORSを回避するために必要 from db import session # DBと接続するためのセッション from model import UserTable, User # 今回使うモデルをインポート from elasticapm.contrib.starlette import make_apm_client, ElasticAPM elastic_apm = make_apm_client({'SERVER_URL': 'http://127.0.0.1:8200'}) app = FastAPI() app.add_middleware(ElasticAPM, client=elastic_apm) # CORSを回避するために設定 app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) # ----------APIの実装------------ # テーブルにいる全ユーザ情報を取得 GET @app.get("/users") def read_users(): users = session.query(UserTable).all() return users # idにマッチするユーザ情報を取得 GET
import asyncio import os import time from dotenv import load_dotenv from elasticapm.contrib.starlette import ElasticAPM, make_apm_client from fastapi import Depends, FastAPI load_dotenv() ELASTIC_SERVICE_NAME = os.getenv("ELASTIC_SERVICE_NAME") ELASTIC_APM_SERVER_URL = os.getenv("ELASTIC_APM_SERVER_URL") apm = make_apm_client({ "SERVICE_NAME": ELASTIC_SERVICE_NAME, "SERVER_URL": ELASTIC_APM_SERVER_URL }) app = FastAPI() app.add_middleware(ElasticAPM, client=apm) def waiting_dep(): time.sleep(0.1) @app.get("/hello", dependencies=[Depends(waiting_dep)]) async def hello(): await asyncio.sleep(0.1) return "hello"
def initiate_fastapi_apm_client(): from elasticapm.contrib.starlette import make_apm_client config = Utility.initiate_apm_client_config() if config: return make_apm_client(config)