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)
