def post_worker_init(worker): logging.info('beeline initialization in process pid {}'.format(os.getpid())) if os.environ.get('HONEYCOMB_WRITEKEY'): beeline.init( writekey=os.environ['HONEYCOMB_WRITEKEY'], dataset=os.environ['HONEYCOMB_DATASET'], service_name='cert_agent')
def init_beeline(): logging.info("Initializing Honeycomb/Beeline") beeline.init( writekey=WRITEKEY, dataset=DATASET, service_name="reference-honeycomb-traced-stepfunction", debug=False, )
def ready(self): # If you use uwsgi, gunicorn, celery, or other pre-fork models, see the section below on pre-fork # models and do not initialize here. beeline.init( writekey=HONEYCOMB_API_KEY, dataset='confabulations-v3', service_name='confabulations-v3', #debug=True, )
def ready(self): import brator.quiz.signals # Imported for side-effects if settings.HONEYCOMB_API_KEY: beeline.init( writekey=settings.HONEYCOMB_API_KEY, dataset=settings.HONEYCOMB_DATASET, service_name=settings.HONEYCOMB_SERVICE, )
def post_worker_init(worker): worker.log.info("beeline initialization in process pid %s", worker.pid) import os import beeline # only proceed if the environment variables have beens upplied if "HONEYCOMB_WRITEKEY" in os.environ and "HONEYCOMB_DATASET" in os.environ: beeline.init( writekey=os.getenv("HONEYCOMB_WRITEKEY"), dataset=os.getenv("HONEYCOMB_DATASET"), debug=False, )
def inited_app(environ, start_response): if not with_flask_tracing.beeline_inited: beeline.init( writekey=os.environ["HONEYCOMB_KEY"], dataset="IFTTT webhooks", service_name="fructify", presend_hook=presend, ) with_flask_tracing.beeline_inited = True try: return original_wsgi_app(environ, start_response) finally: # Always flush because vercel can suspend the process. beeline.get_beeline().client.flush()
def create_app(config_object=ProdConfig): """An application factory, as explained here: http://flask.pocoo.org/docs/patterns/appfactories/. :param config_object: The configuration object to use. """ beeline.init(writekey=os.environ.get('HONEYCOMB_API_KEY'), dataset="conduit", service_name="conduit", debug=True) app = Flask(__name__.split('.')[0]) HoneyMiddleware(app, db_events=True) app.url_map.strict_slashes = False app.config.from_object(config_object) register_extensions(app) register_blueprints(app) register_errorhandlers(app) register_shellcontext(app) register_commands(app) return app
def send_to_honeycomb(): """Attempts to log usage data to honeycomb. Honeycomb logging is completely optional. If there are any failures simply continue as normal. This includes if clrenv can not be loaded. These metrics are sent to honeycomb as an event rather than a trace for two reasons: 1) They don't really fit the web requests model. 2) Downstream code might have its own tracing which we don't want to interfere with. """ try: from clrenv import env # clrenv < 0.2.0 has a bug in the `in` operator at the root level. if env.get("honeycomb") is None: return beeline.init( writekey=env.honeycomb.writekey, dataset="clr", service_name="clr", ) # Convert start_time into a duration. honeycomb_data["duration_ms"] = int( 1000 * (time.time() - honeycomb_data["start_time"])) del honeycomb_data["start_time"] honeycomb_data["username"] = getpass.getuser() honeycomb_data["clr_version"] = __version__ honeycomb_data["color_key_mode"] = env.key_mode beeline.send_now(honeycomb_data) beeline.close() except: if DEBUG_MODE: print("Failed to initialize beeline.", file=sys.stderr) print(traceback.format_exc(), file=sys.stderr)
def post_worker_init(worker: Any) -> None: """ Gunicorn post-forking hook, initializing new process. In this case, we use it primarily for instrumentation and telemetry setup. Data will only get sent to honeycomb when we define the following environment variable: `HONEYCOMB_KEY`. If it is not defined, it will verbosely print to stderr what info it would have sent there. No valid API key would then be necessary. """ logging.info(f"beeline initialization on process pid {os.getpid()}") honeycomb_key = os.getenv("HONEYCOMB_KEY", "") # if no api key, do not send data and instead print what would be sent to stderr # if we have a key, pass data to honeycomb.io args = { "writekey": honeycomb_key, "dataset": "blossom", "debug": True if len(honeycomb_key) == 0 else False, "sample_rate": 10, } beeline.init(**args) atexit.register(beeline.close)
def honeycomb_send(data): """ ships a list or a dict of data to honeycomb """ beeline.init(writekey=HONEY_WRITEKEY, dataset=DATASET_NAME, debug=HONEY_DEBUG_ENABLED, block_on_send=True) LOG.debug(f'sending to honeycomb: {data}') client = beeline.get_beeline().client if not isinstance(data, list): data = [data] for eventdata in data: ev = client.new_event() ev.add(eventdata) ev.send() client.flush() LOG.info(f'{len(data)} events shipped to honeycomb ..')
).json()['Data']['slots'] possible_availability = slots != KNOWN_NO_SLOTS stores.append({ 'id': store_id, 'address': store_data['address'], 'possible_availability': possible_availability, 'zip': store_data['zipcode'], 'phone': store_data['fullPhone'], }) @app.after_request def after_request(response): header = response.headers header['Access-Control-Allow-Origin'] = '*' return response if __name__ == "__main__": key = os.environ.get('HONEYCOMB_API_KEY') if key: beeline.init( writekey=key, dataset='riteaid-covid', service_name='riteaid-covid-http', ) waitress.serve(app, listen='*:80')
import beeline from beeline.middleware.flask import HoneyMiddleware from flask import Flask from local_secrets import honeycomb_api_key beeline.init( writekey=honeycomb_api_key, dataset="taas", service_name="taas", debug=True, ) app = Flask(__name__) HoneyMiddleware(app, db_events=True) @app.route("/hello") def hello_world(): return "Hello, World!"
print("Couldn't start cloud debugger") except ImportError: print("Couldn't import google exceptions") import json from os import environ import beeline from beeline.middleware.flask import HoneyMiddleware from flask import Flask, request, jsonify app = Flask(__name__) if environ.get('HONEYCOMB_KEY'): beeline.init(writekey=environ['HONEYCOMB_KEY'], dataset='rws', service_name='lp') HoneyMiddleware(app, db_events=True) with open('language_packs.json') as f: languages = json.load(f)['languages'] def urlify(pack): return {**pack, 'file': f"https://binaries.rebble.io/lp/{pack['file']}"} @app.route('/heartbeat') @app.route('/lp/heartbeat') def heartbeat(): return 'ok'
from .models import ( PaymentProvider, Person, Company, Module, ) from .blueprints.admin import get_subscription_status load_dotenv(verbose=True) PYTHON_LOG_LEVEL = os.environ.get("PYTHON_LOG_LEVEL", "WARNING") logging.basicConfig(level=PYTHON_LOG_LEVEL) beeline.init( writekey=os.environ.get("HONEYCOMB_API_KEY"), dataset="subscribie", service_name="subscribie", ) def seed_db(): pass def create_app(test_config=None): app = Flask(__name__, instance_relative_config=True) HoneyMiddleware( app, db_events=True ) # db_events defaults to True, set to False if not using our db middleware with Flask-SQLAlchemy load_dotenv(verbose=True) app.config.update(os.environ)
from flask import Flask, session, redirect, url_for, render_template, request, send_from_directory from beeline.middleware.flask import HoneyMiddleware import werkzeug from werkzeug.middleware.proxy_fix import ProxyFix from flask_sslify import SSLify from .stage1 import init_app as init_stage1 from .stage2 import init_app as init_stage2 from .auth import rebble, init_app as init_auth from .settings import config app = Flask(__name__) app.config.update(**config) if config['HONEYCOMB_KEY']: beeline.init(writekey=config['HONEYCOMB_KEY'], dataset='rws', service_name='boot') HoneyMiddleware(app, db_events=True) app.wsgi_app = ProxyFix(app.wsgi_app, x_proto=1, x_host=1) sslify = SSLify(app, skips=['heartbeat']) if not app.debug: app.config['PREFERRED_URL_SCHEME'] = 'https' init_stage1(app) init_stage2(app) init_auth(app) # XXX: upstream this import beeline @app.before_request
sample_rate = 1 response_code = fields.get('response.status_code') if response_code != 200: sample_rate = 1 if _should_sample(fields.get('trace.trace_id'), sample_rate): return True, sample_rate return False, 0 app = Flask(__name__) CSRFProtect(app) app.config.update(**config) beeline.init(writekey=config['HONEYCOMB_KEY'], dataset='rws', service_name='auth', sampler_hook=sampler) HoneyMiddleware(app, db_events=True) sslify = SSLify(app, skips=['heartbeat']) if not app.debug: app.config['PREFERRED_URL_SCHEME'] = 'https' init_db(app) init_redis(app) init_login(app) init_oauth(app) init_billing(app) init_api(app) init_wizard(app) # XXX: upstream this import beeline
def init_beeline(): logging.info(f'beeline initialization in process pid {os.getpid()}') beeline.init(writekey="f9e0f7c58be2dde4c878162daed00123", dataset="rs-payment", debug=True)
from splitter_cache import SplitterCache import atexit load_dotenv() logging.basicConfig(level=logging.INFO) app = Flask(__name__) CORS(app) honeycomb_key = os.getenv("HONEYCOMB_KEY") if honeycomb_key: logging.info("honeycomb: initializing") beeline.init(writekey=honeycomb_key, dataset="speculaas", service_name="pieces-finder") HoneyMiddleware(app, db_events=False) logging.info("honeycomb: initialized") else: logging.info("honeycomb: skipping") precomputed_dir = sys.argv[1] layout_dir = sys.argv[2] layout_registry = LayoutRegistry.from_dir(layout_dir) splitter = PreComputedLookupSplitter.from_dir(precomputed_dir, layout_registry) splitter_cache = SplitterCache(splitter) pre_cache_completed = False @app.route("/healthcheck/alive")
"com.apple.mobiletimer", "com.apple.news", "com.apple.podcasts", "com.apple.reminders", "com.apple.shortcuts", "com.apple.stocks", "com.apple.store.Jolly", "com.apple.tips", "com.apple.tv", "com.apple.weather" )) app = Flask(__name__) if environ.get('HONEYCOMB_KEY'): beeline.init(writekey=environ['HONEYCOMB_KEY'], dataset='rws', service_name='notif-app-icons') HoneyMiddleware(app, db_events=True) def get_apple_image_url(bundle_id, country): response = requests.get('https://itunes.apple.com/lookup', params={'bundleId': bundle_id, 'country': country}) response.raise_for_status() results = response.json()['results'] if len(results) == 0: abort(404) return results[0]['artworkUrl512'] def rescale_image(original_url, size, out_f): response = requests.get(original_url) response.raise_for_status()
from datetime import datetime, timezone, timedelta import beeline from beeline.middleware.awslambda import beeline_wrapper from nacl.signing import VerifyKey from nacl.exceptions import BadSignatureError DISCORD_PUBLIC_KEY = os.environ["DISCORD_PUBLIC_KEY"] DISCORD_CLIENT_ID = os.environ["DISCORD_CLIENT_ID"] HONEYCOMB_API_KEY = os.environ.get("HONEYCOMB_API_KEY") verify = VerifyKey(bytes.fromhex(DISCORD_PUBLIC_KEY)).verify beeline.init(writekey=HONEYCOMB_API_KEY, dataset="discordbot-test", service_name="authorizer") class BadTimestampError(Exception): pass @beeline_wrapper def lambda_handler(event, context): headers = {key.lower(): value for key, value in event["headers"].items()} signature = headers["x-signature-ed25519"] timestamp = headers["x-signature-timestamp"] body = event["body"] try:
ch.setFormatter( logging.Formatter( '%(asctime)s [%(processName)s] %(levelname)s %(message)s')) logger.addHandler(ch) # when running inside docker, the default SIGINT signal handler is not installed, # so the KeyboardInterrupt is not triggered. This should install it manually: # https://stackoverflow.com/a/40785230 signal.signal(signal.SIGINT, signal.default_int_handler) # application performance monitoring: HONEYCOMP_APM_API_KEY = os.environ.get('HONEYCOMP_APM_API_KEY') beeline_client = None if HONEYCOMP_APM_API_KEY: beeline.init(writekey=HONEYCOMP_APM_API_KEY, dataset='OpenEO - workers', service_name='OpenEO') beeline_client = beeline.get_beeline().client def _feed_monitoring_system(): if not HONEYCOMP_APM_API_KEY: return # https://docs.python.org/3/library/resource.html rusage_parent = resource.getrusage(resource.RUSAGE_SELF) rusage_children = resource.getrusage(resource.RUSAGE_CHILDREN) metric_peak_memory = (rusage_parent.ru_maxrss + rusage_children.ru_maxrss) * resource.getpagesize() metric_cpu = psutil.cpu_percent()
import datetime import os import time import beeline from beeline.middleware.flask import HoneyMiddleware from beeline.patch import requests import requests from flask import Flask, request, jsonify, abort from werkzeug.exceptions import HTTPException from werkzeug.routing import FloatConverter app = Flask(__name__) if os.environ.get('HONEYCOMB_KEY'): beeline.init(writekey=os.environ['HONEYCOMB_KEY'], dataset='rws', service_name='weather') HoneyMiddleware(app, db_events = True) auth_internal = os.environ['REBBLE_AUTH_URL_INT'] ibm_root = os.environ['IBM_API_ROOT'] http_protocol = os.environ.get('HTTP_PROTOCOL', 'https') # For some reason, the standard float converter rejects negative numbers # (and also integers without a decimal point). class SignedFloatConverter(FloatConverter): regex = r'-?\d+(\.\d+)?' app.url_map.converters['float'] = SignedFloatConverter
from flask import Flask, jsonify, request, abort from beeline.patch import requests import requests app = Flask(__name__) with open('./config.json') as f: fw_config = json.load(f) app.config['HONEYCOMB_KEY'] = os.environ.get('HONEYCOMB_KEY', None) app.config['REBBLE_AUTH'] = os.environ['REBBLE_AUTH'] app.config['FIRMWARE_ROOT'] = os.environ.get('FIRMWARE_ROOT', 'https://binaries.rebble.io/fw') if app.config['HONEYCOMB_KEY']: beeline.init(writekey=app.config['HONEYCOMB_KEY'], dataset='rws', service_name='cohorts') HoneyMiddleware(app) # TODO: Something like this probably belongs in a common library def require_auth(fn): @wraps(fn) def wrapper(*args, **kwargs): auth = request.headers.get('Authorization') if auth is None: abort(401) result = requests.get(f"{app.config['REBBLE_AUTH']}/api/v1/me", headers={'Authorization': auth}) if result.status_code != 200: abort(401)
import os import re import beeline import requests from aws_lambda_powertools.logging import Logger from beeline.middleware.awslambda import beeline_wrapper beeline.init( # Get this via https://ui.honeycomb.io/account after signing up for Honeycomb writekey='d2c268adc6ba3802eb7ba81dcd2e545e', # The name of your app is a good choice to start with dataset='console-signin', service_name='console-signin', # debug=True, # defaults to False. if True, data doesn't get sent to Honeycomb ) logger = Logger(service="Console Sign-in") class SlackMessage: def __init__(self, user_arn): self.user_arn = user_arn def _user_name(self): """ Extracts the username from an AWS User ARN Parameters: self.user_arn (string): AWS User ARN, e.g. arn:aws:iam::123456789012:user/[email protected]
None) JSON_FAILURE_RESPONSE = ('{"error":"failed to unmarshal JSON body"}', 400, None) DATASET_LOOKUP_FAILURE_RESPONSE = ( '{"error":"failed to resolve dataset object"}', 400, None) SCHEMA_LOOKUP_FAILURE_RESPONSE = ('{"error":"failed to resolve schema"}', 500, None) honeycomb_write_key = os.environ.get("HONEYCOMB_WRITEKEY") if not honeycomb_write_key: log.error( "Got empty writekey from the environment. Please set HONEYCOMB_WRITEKEY" ) beeline.init(writekey=honeycomb_write_key, dataset='apiary-python', service_name='sample_app') app = Flask(__name__) HoneyMiddleware(app, db_events=False) @app.route('/') def home(): return render_template('home.html') @app.route('/x/alive') def health(): return json.dumps({'alive': 'yes'})
import beeline import os from beeline.middleware.flask import HoneyMiddleware from flask import Flask honeycomb_writekey = os.environ.get("HONEYCOMB_API_KEY") beeline.init(writekey=honeycomb_writekey, dataset="my-flask-app", service_name="my-flask-app-service") # Pass your Flask app to HoneyMiddleware app = Flask(__name__) HoneyMiddleware(app, db_events=False) @app.route("/") def hello_world(): span = beeline.start_span(context={"name": "Preparing to greet the world"}) message = "Hello World" beeline.add_trace_field('message', message) beeline.finish_span(span) return message
def post_worker_init(worker): logging.info(f"beeline initialization in process pid {os.getpid()}") beeline.init(writekey=os.environ["HONEYCOMB_API_KEY"], dataset="mutants-api", debug=True)
def init(app, service): beeline.init(service_name=service, sampler_hook=_sampler) HoneyMiddleware(app, db_events=True)
import os from pwgen import pwgen from flask import Flask from flask import render_template from flask import Response from werkzeug.middleware.dispatcher import DispatcherMiddleware from prometheus_client import make_wsgi_app, Counter, Gauge import subprocess import docker import beeline from beeline.middleware.flask import HoneyMiddleware beeline.init( writekey=os.getenv('HONEYCOMB_API', None), dataset='poc-pwgen', service_name='pwgen', ) app = Flask(__name__) app.wsgi_app = DispatcherMiddleware(app.wsgi_app, {'/metrics': make_wsgi_app()}) single_count = Counter('single_requests', 'Requests of single passwd') multi_count = Counter('multi_requests', 'Requests of multiple passwds') str_single_count = Counter('str_single', 'Requests of string-only single passwd') str_multi_count = Counter('str_multi', 'Requests of string-only multi passwd') short_hash = str( subprocess.check_output(['git', 'rev-parse', '--short', 'HEAD']), 'utf-8').strip()
from splortshub.client import initialize from splortshub.tracing import HoneycombMiddleware class Settings(BaseSettings): blaseball_auth_cookie: str honey_api_key: Optional[str] honey_dataset: str = "splortshub-api" honey_debug: bool = False settings = Settings() initialize(settings.blaseball_auth_cookie) app = FastAPI() app.include_router(status.router) app.include_router(teams.router) app.include_router(players.router) app.add_middleware(HoneycombMiddleware) if settings.honey_api_key: beeline.init( writekey=settings.honey_api_key, dataset=settings.honey_dataset, debug=settings.honey_debug, ) @app.get("/") async def root(): return {"splorts": True}