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}
