def __init__(self) -> None: self.app = web.Application() self.routes = web.RouteTableDef() self.pyctuator = Pyctuator( self.app, "AIOHTTP Pyctuator", "http://*****:*****@self.routes.get("/logfile_test_repeater") async def logfile_test_repeater(request: web.Request) -> web.Response: repeated_string = request.query.get("repeated_string") logging.error(repeated_string) return web.Response(text=repeated_string) @self.routes.get("/httptrace_test_url") async def get_httptrace_test_url(request: web.Request) -> web.Response: # Sleep if requested to sleep - used for asserting httptraces timing sleep_sec = request.query.get("sleep_sec") if sleep_sec: logging.info("Sleeping %s seconds before replying", sleep_sec) time.sleep(int(sleep_sec)) # Echo 'User-Data' header as 'resp-data' - used for asserting headers are captured properly return web.Response(headers={"resp-data": str(request.headers.get("User-Data"))}, body="my content") self.app.add_routes(self.routes) self.thread = threading.Thread(target=self._start_in_thread) self.should_stop_server = False self.server_started = False
def __init__(self) -> None: self.app = Flask("Flask Example Server") self.thread = threading.Thread(target=self.app.run) self.pyctuator = Pyctuator(self.app, "Flask Pyctuator", "http://*****:*****@self.app.route("/shutdown", methods=["POST"]) # pylint: disable=unused-variable def shutdown() -> str: logging.info("Flask server shutting down...") func = request.environ.get("werkzeug.server.shutdown") if func is None: raise RuntimeError("Not running with the Werkzeug Server") func() return "Flask server off" @self.app.route("/logfile_test_repeater") # pylint: disable=unused-variable def logfile_test_repeater() -> str: repeated_string: str = str(request.args.get('repeated_string')) logging.error(repeated_string) return repeated_string @self.app.route("/httptrace_test_url", methods=["GET"]) # pylint: disable=unused-variable def get_httptrace_test_url() -> Response: resp = Response() resp.headers["resp-data"] = str(request.headers.get('User-Data')) return resp
def __init__(self) -> None: self.app = FastAPI( title="FastAPI Example Server", description="Demonstrate Spring Boot Admin Integration with FastAPI", docs_url="/api", ) self.pyctuator = Pyctuator( self.app, "FastAPI Pyctuator", "http://*****:*****@self.app.get("/logfile_test_repeater", tags=["pyctuator"]) # pylint: disable=unused-variable def logfile_test_repeater(repeated_string: str) -> str: logging.error(repeated_string) return repeated_string self.server = CustomServer(config=(Config(app=self.app, loop="asyncio"))) self.thread = threading.Thread(target=self.server.run) @self.app.get("/httptrace_test_url") # pylint: disable=unused-variable def get_httptrace_test_url(request: Request, sleep_sec: Optional[int]) -> Response: # Sleep if requested to sleep - used for asserting httptraces timing if sleep_sec: logging.info("Sleeping %s seconds before replying", sleep_sec) time.sleep(sleep_sec) # Echo 'User-Data' header as 'resp-data' - used for asserting headers are captured properly return Response(headers={"resp-data": str(request.headers.get("User-Data"))}, content="my content")
def __init__(self) -> None: self.app = FastAPI( title="FastAPI Example Server", description= "Demonstrate Spring Boot Admin Integration with FastAPI", docs_url="/api", ) self.pyctuator = Pyctuator( self.app, "FastAPI Pyctuator", "http://*****:*****@self.app.get("/logfile_test_repeater", tags=["pyctuator"]) # pylint: disable=unused-variable def logfile_test_repeater(repeated_string: str) -> str: logging.error(repeated_string) return repeated_string self.server = CustomServer( config=(Config(app=self.app, loop="asyncio"))) self.thread = threading.Thread(target=self.server.run) @self.app.get("/httptrace_test_url") # pylint: disable=unused-variable def get_httptrace_test_url(request: Request) -> Response: return Response( headers={"resp-data": str(request.headers.get("User-Data"))}, content="my content")
class FlaskPyctuatorServer(PyctuatorServer): def __init__(self) -> None: self.app = Flask("Flask Example Server") self.thread = threading.Thread(target=self.app.run) self.pyctuator = Pyctuator( self.app, "Flask Pyctuator", "http://*****:*****@self.app.route("/shutdown", methods=["POST"]) # pylint: disable=unused-variable def shutdown() -> str: logging.info("Flask server shutting down...") func = request.environ.get("werkzeug.server.shutdown") if func is None: raise RuntimeError("Not running with the Werkzeug Server") func() return "Flask server off" @self.app.route("/logfile_test_repeater") # pylint: disable=unused-variable def logfile_test_repeater() -> str: repeated_string: str = str(request.args.get("repeated_string")) logging.error(repeated_string) return repeated_string @self.app.route("/httptrace_test_url", methods=["GET"]) # pylint: disable=unused-variable def get_httptrace_test_url() -> Response: # Sleep if requested to sleep - used for asserting httptraces timing sleep_sec = request.args.get("sleep_sec") if sleep_sec: logging.info("Sleeping %s seconds before replying", sleep_sec) time.sleep(int(sleep_sec)) # Echo 'User-Data' header as 'resp-data' - used for asserting headers are captured properly resp = Response() resp.headers["resp-data"] = str(request.headers.get("User-Data")) return resp def start(self) -> None: self.thread.start() while True: time.sleep(0.5) try: requests.get("http://localhost:5000/pyctuator") return except requests.exceptions.RequestException: # Catches all exceptions that Requests raises! pass def stop(self) -> None: self.pyctuator.stop() requests.post("http://localhost:5000/shutdown") self.thread.join()
def __init__(self) -> None: # pylint: disable=abstract-method class LogfileTestRepeater(RequestHandler): def get(self) -> None: repeated_string = self.get_argument("repeated_string") logging.error(repeated_string) self.write(repeated_string) # pylint: disable=abstract-method class GetHttptraceTestUrl(RequestHandler): def get(self) -> None: sleep_sec: Optional[str] = self.get_argument("sleep_sec", None) # Sleep if requested to sleep - used for asserting httptraces timing if sleep_sec: logging.info("Sleeping %s seconds before replying", sleep_sec) time.sleep(int(sleep_sec)) # Echo 'User-Data' header as 'resp-data' - used for asserting headers are captured properly self.add_header("resp-data", str(self.request.headers.get("User-Data"))) self.add_header("response-secret", "my password") self.write("my content") self.app = Application( [("/logfile_test_repeater", LogfileTestRepeater), ("/httptrace_test_url", GetHttptraceTestUrl)], debug=True) self.pyctuator = Pyctuator( self.app, "Tornado Pyctuator", app_url=f"http://localhost:5000", pyctuator_endpoint_url=f"http://localhost:5000/pyctuator", registration_url=f"http://localhost:8001/register", app_description= "Demonstrate Spring Boot Admin Integration with Tornado", registration_interval_sec=1, metadata=self.metadata, ) self.io_loop: Optional[ioloop.IOLoop] = None self.http_server = HTTPServer(self.app, decompress_request=True) self.thread = threading.Thread(target=self._start_in_thread)
from pyctuator.pyctuator import Pyctuator logging.basicConfig(level=logging.INFO) my_logger = logging.getLogger("example") app = web.Application() routes = web.RouteTableDef() @routes.get('/') def home(request: web.Request) -> web.Response: my_logger.debug( f"{datetime.datetime.now()} - {str(random.randint(0, 100))}") print("Printing to STDOUT") return web.Response(text="Hello World!") example_app_address = "host.docker.internal" example_sba_address = "localhost" pyctuator = Pyctuator( app, "Example aiohttp", app_url=f"http://{example_app_address}:8888", pyctuator_endpoint_url=f"http://{example_app_address}:8888/pyctuator", registration_url=f"http://{example_sba_address}:8082/instances", app_description="Demonstrate Spring Boot Admin Integration with aiohttp", ) app.add_routes(routes) web.run_app(app, port=8888)
class FastApiPyctuatorServer(PyctuatorServer): def __init__(self) -> None: self.app = FastAPI( title="FastAPI Example Server", description= "Demonstrate Spring Boot Admin Integration with FastAPI", docs_url="/api", ) self.pyctuator = Pyctuator( self.app, "FastAPI Pyctuator", "http://*****:*****@self.app.get("/logfile_test_repeater", tags=["pyctuator"]) # pylint: disable=unused-variable def logfile_test_repeater(repeated_string: str) -> str: logging.error(repeated_string) return repeated_string self.server = CustomServer( config=(Config(app=self.app, loop="asyncio"))) self.thread = threading.Thread(target=self.server.run) @self.app.get("/httptrace_test_url") # pylint: disable=unused-variable def get_httptrace_test_url(request: Request, sleep_sec: Optional[int]) -> Response: # Sleep if requested to sleep - used for asserting httptraces timing if sleep_sec: logging.info("Sleeping %s seconds before replying", sleep_sec) time.sleep(sleep_sec) # Echo 'User-Data' header as 'resp-data' - used for asserting headers are captured properly return Response( headers={"resp-data": str(request.headers.get("User-Data"))}, content="my content") def start(self) -> None: self.thread.start() while not self.server.started: time.sleep(0.01) def stop(self) -> None: logging.info("Stopping FastAPI server") self.pyctuator.stop() # Allow the recurring registration to complete any in-progress request before stopping FastAPI time.sleep(1) self.server.should_exit = True self.server.force_exit = True self.thread.join() logging.info("FastAPI server stopped") def atexit(self) -> None: if self.pyctuator.boot_admin_registration_handler: self.pyctuator.boot_admin_registration_handler.deregister_from_admin_server( )
@app.get("/") def read_root(): my_logger.debug( f"{datetime.datetime.now()} - {str(random.randint(0, 100))}") print("Printing to STDOUT") return "Hello World!" example_app_address = "host.docker.internal" example_sba_address = "localhost" pyctuator = Pyctuator( app, "Example FastAPI", app_url=f"http://{example_app_address}:8000", pyctuator_endpoint_url=f"http://{example_app_address}:8000/pyctuator", registration_url=f"http://{example_sba_address}:8080/instances", app_description=app.description, ) # Keep the console clear - configure uvicorn (FastAPI's WSGI web app) not to log the detail of every incoming request uvicorn_logger = logging.getLogger("uvicorn") uvicorn_logger.setLevel(logging.WARNING) server = Server(config=(Config( app=app, loop="asyncio", host="0.0.0.0", logger=uvicorn_logger, ))) server.run()
# Workaround for starting Faust App without Kafka. # See https://github.com/robinhood/faust/issues/234 class App(faust.App): producer_only = True class BootStrategy(BootStrategy): enable_kafka = False app = App('demo1') pyctuator = Pyctuator(app.web.web_app, "aiohttp Pyctuator", app_url="http://*****:*****@app.crontab('*/2 * * * *') async def test_message(): print('EVERY MINUTE I MESSAGE') if __name__ == '__main__': app.main()
@app.post("/health") def health_up(request: Request, health: Dict) -> None: # health should be of type HealthStatus global app_specific_health app_specific_health = HealthStatus(Status[health["status"]], details=health["details"]) # ---------------------------------------------------------------------------------------------------------------------- # Initialize Pyctuator with the SBA endpoint and all the extensions # ---------------------------------------------------------------------------------------------------------------------- pyctuator = Pyctuator( app, get_conf("app.name"), get_conf("app.public_endpoint"), get_conf("monitoring.pyctuator_endpoint"), get_conf("monitoring.sba_registration_endpoint"), app_description=app.description, ) # Provide app's build info pyctuator.set_build_info( name=get_conf("app.name"), version=get_conf("app.version"), time=get_conf("app.build_time"), ) # Provide git commit info pyctuator.set_git_info( commit=get_conf("app.git.commit"), time=get_conf("app.git.time"),
# Keep the console clear - configure werkzeug (flask's WSGI web app) not to log the detail of every incoming request logging.getLogger("werkzeug").setLevel(logging.WARNING) my_logger = logging.getLogger("example") app = Flask("Flask Example Server") @app.route("/") def hello(): my_logger.debug( f"{datetime.datetime.now()} - {str(random.randint(0, 100))}") print("Printing to STDOUT") return "Hello World!" example_app_address = "host.docker.internal" example_sba_address = "localhost" Pyctuator( app, "Flask Pyctuator", app_url=f"http://{example_app_address}:5000", pyctuator_endpoint_url=f"http://{example_app_address}:5000/pyctuator", registration_url=f"http://{example_sba_address}:8080/instances", app_description="Demonstrate Spring Boot Admin Integration with Flask", ) app.run(port=5000, host="0.0.0.0")
app = FastAPI( title="FastAPI Example Server", description="Demonstrate Spring Boot Admin Integration with FastAPI", docs_url="/api", ) @app.get("/") def read_root(): my_logger.debug(f"{datetime.datetime.now()} - {str(random.randint(0, 100))}") print("Printing to STDOUT") return "Hello World!" example_app_public_address = socket.gethostbyname(socket.gethostname()) example_app_address_as_seen_from_sba_container = "host.docker.internal" example_sba_address = "localhost" pyctuator = Pyctuator( app, "Example FastAPI", f"http://{example_app_public_address}:8000", f"http://{example_app_address_as_seen_from_sba_container}:8000/pyctuator", f"http://{example_sba_address}:8082/instances", app_description=app.description, ) server = Server(config=(Config(app=app, loop="asyncio", host="0.0.0.0"))) server.run()
class TornadoPyctuatorServer(PyctuatorServer): def __init__(self) -> None: # pylint: disable=abstract-method class LogfileTestRepeater(RequestHandler): def get(self) -> None: repeated_string = self.get_argument("repeated_string") logging.error(repeated_string) self.write(repeated_string) # pylint: disable=abstract-method class GetHttptraceTestUrl(RequestHandler): def get(self) -> None: sleep_sec: Optional[str] = self.get_argument("sleep_sec", None) # Sleep if requested to sleep - used for asserting httptraces timing if sleep_sec: logging.info("Sleeping %s seconds before replying", sleep_sec) time.sleep(int(sleep_sec)) # Echo 'User-Data' header as 'resp-data' - used for asserting headers are captured properly self.add_header("resp-data", str(self.request.headers.get("User-Data"))) self.write("my content") self.app = Application( [("/logfile_test_repeater", LogfileTestRepeater), ("/httptrace_test_url", GetHttptraceTestUrl)], debug=True) self.pyctuator = Pyctuator( self.app, "Tornado Pyctuator", app_url=f"http://localhost:5000", pyctuator_endpoint_url=f"http://localhost:5000/pyctuator", registration_url=f"http://localhost:8001/register", app_description= "Demonstrate Spring Boot Admin Integration with Tornado", registration_interval_sec=1, ) self.io_loop: Optional[ioloop.IOLoop] = None self.http_server = HTTPServer(self.app, decompress_request=True) self.thread = threading.Thread(target=self._start_in_thread) def _start_in_thread(self) -> None: self.io_loop = ioloop.IOLoop() self.http_server.listen(5000) self.io_loop.start() def start(self) -> None: logging.info("Starting Tornado server") self.thread.start() time.sleep(0.5) def stop(self) -> None: logging.info("Stopping Tornado server") self.pyctuator.stop() # Allow the recurring registration to complete any in-progress request before stopping Tornado time.sleep(1) assert self.io_loop is not None self.http_server.stop() self.io_loop.add_callback(self.io_loop.stop) self.thread.join() self.io_loop.close(all_fds=True) def atexit(self) -> None: if self.pyctuator.boot_admin_registration_handler: self.pyctuator.boot_admin_registration_handler.deregister_from_admin_server( )
from app.models import User, Paper with app.app_context(): db.create_all() login_user = User.query.filter_by(username=cf.USERNAME).first() if not login_user: u = User(username=cf.USERNAME) u.set_password(cf.PASSWORD) db.session.add(u) db.session.commit() s3 = boto3.resource('s3', aws_access_key_id=cf.ACCESS_KEY, aws_secret_access_key=cf.SECRET_ACCESS_KEY) ssapp_docs = s3.Bucket(cf.S3_BUCKET_NAME) from app import routes, models pyctuator = Pyctuator( app, "Semantic Segment Search", app_url=f"http://{cf.APP_ADDR}:8000", pyctuator_endpoint_url=f"http://{cf.APP_ADDR}:8000/pyctuator", registration_url=f"http://{cf.APP_ADDR}:8080/instances") pyctuator.set_git_info( commit='2f03f40', time='Tue Jul 20 16:24:06 2021 -0700', branch='origin/master', )
# pip install pyctuator import os from flask import Flask from pyctuator.auth import BasicAuth from pyctuator.pyctuator import Pyctuator app_name = "Flask App with Pyctuator" app = Flask(app_name) @app.route("/") def hello(): return "Hello World!" Pyctuator( app, app_name, app_url="http://192.168.99.100:5000", pyctuator_endpoint_url="http://192.168.99.100:5000/pyctuator", registration_url="http://192.168.99.100:9600/instances", registration_auth=BasicAuth(username="******", password="******"), ) app.run(host="0.0.0.0")
# pip install pyctuator import os from flask import Flask from pyctuator.pyctuator import Pyctuator app_name = "Flask App with Pyctuator" app = Flask(app_name) @app.route("/") def hello(): return "Hello World!" Pyctuator(app, app_name, app_url="http://localhost:5000", pyctuator_endpoint_url="http://localhost:5000/pyctuator", registration_url="http://localhost:9000/instances") app.run()
class AiohttpPyctuatorServer(PyctuatorServer): def __init__(self) -> None: self.app = web.Application() self.routes = web.RouteTableDef() self.pyctuator = Pyctuator( self.app, "AIOHTTP Pyctuator", "http://*****:*****@self.routes.get("/logfile_test_repeater") async def logfile_test_repeater(request: web.Request) -> web.Response: repeated_string = request.query.get("repeated_string") logging.error(repeated_string) return web.Response(text=repeated_string) @self.routes.get("/httptrace_test_url") async def get_httptrace_test_url(request: web.Request) -> web.Response: # Sleep if requested to sleep - used for asserting httptraces timing sleep_sec = request.query.get("sleep_sec") if sleep_sec: logging.info("Sleeping %s seconds before replying", sleep_sec) time.sleep(int(sleep_sec)) # Echo 'User-Data' header as 'resp-data' - used for asserting headers are captured properly headers = { "resp-data": str(request.headers.get("User-Data")), "response-secret": "my password" } return web.Response(headers=headers, body="my content") self.app.add_routes(self.routes) self.thread = threading.Thread(target=self._start_in_thread) self.should_stop_server = False self.server_started = False async def _run_server(self) -> None: logging.info("Preparing to start aiohttp server") runner = web.AppRunner(self.app) await runner.setup() logging.info("Starting aiohttp server") site = web.TCPSite(runner, port=8888) await site.start() self.server_started = True logging.info("aiohttp server started") while not self.should_stop_server: await asyncio.sleep(1) logging.info("Shutting down aiohttp server") await runner.shutdown() await runner.cleanup() logging.info("aiohttp server is shutdown") def _start_in_thread(self) -> None: loop = asyncio.new_event_loop() loop.run_until_complete(self._run_server()) loop.stop() def start(self) -> None: self.thread.start() while not self.server_started: time.sleep(0.01) def stop(self) -> None: logging.info("Stopping aiohttp server") self.pyctuator.stop() self.should_stop_server = True self.thread.join() logging.info("aiohttp server stopped") def atexit(self) -> None: if self.pyctuator.boot_admin_registration_handler: self.pyctuator.boot_admin_registration_handler.deregister_from_admin_server()
logging.basicConfig(level=logging.INFO) my_logger = logging.getLogger("example") app = Flask("Flask Example Server") @app.route("/") def hello(): my_logger.debug( f"{datetime.datetime.now()} - {str(random.randint(0, 100))}") print("Printing to STDOUT") return "Hello World!" example_app_public_address = socket.gethostbyname(socket.gethostname()) example_app_address_as_seen_from_sba_container = "host.docker.internal" example_sba_address = "localhost" Pyctuator( app, "Flask Pyctuator", f"http://{example_app_public_address}:5000", f"http://{example_app_address_as_seen_from_sba_container}:5000/pyctuator", f"http://{example_sba_address}:8082/instances", app_description="Demonstrate Spring Boot Admin Integration with Flask", ) app.run(port=5000, host="0.0.0.0")