def create_application():
ereporter2.register_formatter()
# Zap out the ndb in-process cache by default.
# This cache causes excessive memory usage in in handler where a lot of
# entities are fetched in one query. When coupled with high concurrency
# as specified via max_concurrent_requests in app.yaml, this may cause out of
# memory errors.
ndb.Context.default_cache_policy = staticmethod(lambda _key: False)
ndb.Context._cache_policy = staticmethod(lambda _key: False)
# App that serves HTML pages and old API.
frontend = handlers_frontend.create_application(False)
def is_enabled_callback():
return config.settings().enable_ts_monitoring
gae_ts_mon.initialize(frontend, is_enabled_fn=is_enabled_callback)
# App that serves new endpoints API.
endpoints_api = endpoints_webapp2.api_server([
handlers_endpoints_v1.IsolateService,
# components.config endpoints for validation and configuring of
# luci-config service URL.
config.ConfigApi,
])
gae_ts_mon.instrument_wsgi_application(endpoints_api)
prpc_api = webapp2.WSGIApplication(handlers_prpc.get_routes())
return frontend, endpoints_api, prpc_api
def create_application():
ereporter2.register_formatter()
# Zap out the ndb in-process cache by default.
# This cache causes excessive memory usage in in handler where a lot of
# entities are fetched in one query. When coupled with high concurrency
# as specified via max_concurrent_requests in app.yaml, this may cause out of
# memory errors.
ndb.Context.default_cache_policy = staticmethod(lambda _key: False)
ndb.Context._cache_policy = staticmethod(lambda _key: False)
# If running on a local dev server, allow bots to connect without prior
# groups configuration. Useful when running smoke test.
if utils.is_local_dev_server():
acl.bootstrap_dev_server_acls()
pools_config.bootstrap_dev_server_acls()
def is_enabled_callback():
return config.settings().enable_ts_monitoring
backend_app = handlers_backend.create_application(False)
gae_ts_mon.initialize(backend_app, is_enabled_fn=is_enabled_callback)
# Local import, because it instantiates the mapreduce app.
# This is for the task queue handlers.
from mapreduce import main
gae_ts_mon.initialize(main.APP, is_enabled_fn=is_enabled_callback)
event_mon_metrics.initialize()
ts_mon_metrics.initialize()
utils.report_memory(backend_app)
return backend_app, main.APP
def initialize(): # pragma: no cover
"""Bootstraps the global state and creates WSGI applications."""
ereporter2.register_formatter()
apps = (create_html_app(), create_endpoints_app(), create_backend_app())
for app in apps:
gae_ts_mon.initialize(app=app)
return apps
def create_application():
ereporter2.register_formatter()
backend = handlers_backend.create_application(False)
def is_enabled_callback():
return config.settings().enable_ts_monitoring
gae_ts_mon.initialize(backend, is_enabled_fn=is_enabled_callback)
return backend
def create_backend_app(): # pragma: no cover
"""Returns WSGI app for backend."""
routes = handlers.get_backend_routes() + swarming.get_backend_routes()
app = webapp2.WSGIApplication(routes, debug=utils.is_local_dev_server())
gae_ts_mon.initialize(app, cron_module='backend')
gae_ts_mon.register_global_metrics(metrics.GLOBAL_METRICS)
gae_ts_mon.register_global_metrics_callback('buildbucket_global',
metrics.update_global_metrics)
return app
def create_application():
ereporter2.register_formatter()
backend = handlers_backend.create_application(False)
def is_enabled_callback():
return config.settings().enable_ts_monitoring
gae_ts_mon.initialize(backend, is_enabled_fn=is_enabled_callback)
return backend
def main():
utils.set_task_queue_module('default')
apps = (
handlers_endpoints.create_endpoints_app(),
handlers_cron.create_cron_app(),
handlers_frontend.create_frontend_app(),
handlers_queues.create_queues_app(),
)
for app in apps:
gae_ts_mon.initialize(app=app, is_enabled_fn=is_enabled_callback)
return apps
def create_application():
ereporter2.register_formatter()
# Task queues must be sent to the backend.
utils.set_task_queue_module('backend')
template.bootstrap()
# Zap out the ndb in-process cache by default.
# This cache causes excessive memory usage in in handler where a lot of
# entities are fetched in one query. When coupled with high concurrency
# as specified via max_concurrent_requests in app.yaml, this may cause out of
# memory errors.
ndb.Context.default_cache_policy = staticmethod(lambda _key: False)
ndb.Context._cache_policy = staticmethod(lambda _key: False)
# If running on a local dev server, allow bots to connect without prior
# groups configuration. Useful when running smoke test.
if utils.is_local_dev_server():
acl.bootstrap_dev_server_acls()
pools_config.bootstrap_dev_server_acls()
def is_enabled_callback():
return config.settings().enable_ts_monitoring
# App that serves HTML pages and old API.
frontend_app = handlers_frontend.create_application(False)
gae_ts_mon.initialize(frontend_app, is_enabled_fn=is_enabled_callback)
endpoints_api = endpoints_webapp2.api_server([
handlers_endpoints.SwarmingServerService,
handlers_endpoints.SwarmingTaskService,
handlers_endpoints.SwarmingTasksService,
handlers_endpoints.SwarmingQueuesService,
handlers_endpoints.SwarmingBotService,
handlers_endpoints.SwarmingBotsService,
# components.config endpoints for validation and configuring of luci-config
# service URL.
config.ConfigApi,
])
prpc_api = webapp2.WSGIApplication(handlers_prpc.get_routes())
# Local import, because it instantiates the mapreduce app.
# This is for the Web UI.
from mapreduce import main
gae_ts_mon.initialize(main.APP, is_enabled_fn=is_enabled_callback)
event_mon_metrics.initialize()
ts_mon_metrics.initialize()
utils.report_memory(frontend_app)
utils.report_memory(endpoints_api)
utils.report_memory(prpc_api)
return frontend_app, endpoints_api, prpc_api, main.APP
def create_application():
ereporter2.register_formatter()
# App that serves HTML pages and old API.
frontend = handlers_frontend.create_application(False)
def is_enabled_callback():
return config.settings().enable_ts_monitoring
gae_ts_mon.initialize(frontend, is_enabled_fn=is_enabled_callback)
# App that serves new endpoints API.
api = endpoints.api_server([handlers_endpoints_v1.IsolateService])
return frontend, api
def create_application():
ereporter2.register_formatter()
# App that serves HTML pages and old API.
frontend = handlers_frontend.create_application(False)
def is_enabled_callback():
return config.settings().enable_ts_monitoring
gae_ts_mon.initialize(frontend, is_enabled_fn=is_enabled_callback)
# App that serves new endpoints API.
api = endpoints.api_server([handlers_endpoints_v1.IsolateService])
return frontend, api
def create_backend_app(): # pragma: no cover
"""Returns WSGI app for backend."""
routes = handlers.get_backend_routes() + swarming.get_routes()
app = webapp2.WSGIApplication(routes, debug=utils.is_local_dev_server())
gae_ts_mon.initialize(app, cron_module='backend')
gae_ts_mon.register_global_metrics([
metrics.CURRENTLY_PENDING,
metrics.CURRENTLY_RUNNING,
metrics.LEASE_LATENCY,
metrics.SCHEDULING_LATENCY,
])
gae_ts_mon.register_global_metrics_callback(
'send_metrics', metrics.send_all_metrics)
return app
def main():
utils.set_task_queue_module('default')
apps = (
handlers_endpoints.create_endpoints_app(),
handlers_frontend.create_frontend_app(),
handlers_cron.create_cron_app(),
handlers_queues.create_queues_app(),
)
for app in apps[1:]:
# Not callable on endpoints app
gae_ts_mon.initialize(app=app, is_enabled_fn=is_enabled_callback)
gae_event_mon.initialize('gce-backend')
metrics.initialize()
return apps
def create_application():
ereporter2.register_formatter()
# Zap out the ndb in-process cache by default.
# This cache causes excessive memory usage in in handler where a lot of
# entities are fetched in one query. When coupled with high concurrency
# as specified via max_concurrent_requests in app.yaml, this may cause out of
# memory errors.
ndb.Context.default_cache_policy = staticmethod(lambda _key: False)
ndb.Context._cache_policy = staticmethod(lambda _key: False)
backend = handlers_backend.create_application(False)
def is_enabled_callback():
return config.settings().enable_ts_monitoring
gae_ts_mon.initialize(backend, is_enabled_fn=is_enabled_callback)
return backend
def create_application():
ereporter2.register_formatter()
def is_enabled_callback():
return config.settings().enable_ts_monitoring
# App that serves HTML pages and old API.
frontend_app = handlers_frontend.create_application(False)
gae_ts_mon.initialize(frontend_app, is_enabled_fn=is_enabled_callback)
# Local import, because it instantiates the mapreduce app.
from mapreduce import main
gae_ts_mon.initialize(main.APP, is_enabled_fn=is_enabled_callback)
api = endpoints.api_server([
handlers_endpoints.swarming_api,
# components.config endpoints for validation and configuring of luci-config
# service URL.
config.ConfigApi,
])
ts_mon_metrics.initialize()
return frontend_app, api, main.APP
def create_application():
ereporter2.register_formatter()
def is_enabled_callback():
return config.settings().enable_ts_monitoring
# App that serves HTML pages and old API.
frontend_app = handlers_frontend.create_application(False)
gae_ts_mon.initialize(frontend_app, is_enabled_fn=is_enabled_callback)
# Local import, because it instantiates the mapreduce app.
from mapreduce import main
gae_ts_mon.initialize(main.APP, is_enabled_fn=is_enabled_callback)
api = endpoints.api_server([
handlers_endpoints.swarming_api,
# components.config endpoints for validation and configuring of luci-config
# service URL.
config.ConfigApi,
])
ts_mon_metrics.initialize()
return frontend_app, api, main.APP
def create_application():
ereporter2.register_formatter()
# App that serves HTML pages and old API.
frontend = handlers_frontend.create_application(False)
def is_enabled_callback():
return config.settings().enable_ts_monitoring
gae_ts_mon.initialize(frontend, is_enabled_fn=is_enabled_callback)
# App that serves new endpoints API.
api = webapp2.WSGIApplication(
endpoints_webapp2.api_server(
[
handlers_endpoints_v1.IsolateService,
# components.config endpoints for validation and configuring of
# luci-config service URL.
config.ConfigApi,
],
base_path='/_ah/api'))
return frontend, api
def create_application():
ereporter2.register_formatter()
utils.set_task_queue_module('backend')
template.bootstrap()
# If running on a local dev server, allow bots to connect without prior
# groups configuration. Useful when running smoke test.
if utils.is_local_dev_server():
acl.bootstrap_dev_server_acls()
def is_enabled_callback():
return config.settings().enable_ts_monitoring
# App that serves HTML pages and old API.
frontend_app = handlers_frontend.create_application(False)
gae_ts_mon.initialize(frontend_app, is_enabled_fn=is_enabled_callback)
# App that contains crons and task queues.
backend_app = handlers_backend.create_application(False)
gae_ts_mon.initialize(backend_app, is_enabled_fn=is_enabled_callback)
# Local import, because it instantiates the mapreduce app.
from mapreduce import main
gae_ts_mon.initialize(main.APP, is_enabled_fn=is_enabled_callback)
# TODO(maruel): Remove this once there is no known client anymore.
api = webapp2.WSGIApplication(
endpoints_webapp2.api_server(
[
handlers_endpoints.SwarmingServerService,
handlers_endpoints.SwarmingTaskService,
handlers_endpoints.SwarmingTasksService,
handlers_endpoints.SwarmingQueuesService,
handlers_endpoints.SwarmingBotService,
handlers_endpoints.SwarmingBotsService,
# components.config endpoints for validation and configuring of luci-config
# service URL.
config.ConfigApi,
],
base_path='/_ah/api'))
event_mon_metrics.initialize()
ts_mon_metrics.initialize()
return frontend_app, api, backend_app, main.APP
('/', main.MainHandler),
('/mark_recovered_alerts',
mark_recovered_alerts.MarkRecoveredAlertsHandler),
('/memory_report', memory_report.MemoryReportHandler),
('/migrate_test_names', migrate_test_names.MigrateTestNamesHandler),
('/deprecate_tests', deprecate_tests.DeprecateTestsHandler),
('/navbar', navbar.NavbarHandler),
('/pinpoint/new/bisect',
pinpoint_request.PinpointNewBisectRequestHandler),
('/pinpoint/new/perf_try',
pinpoint_request.PinpointNewPerfTryRequestHandler),
('/pinpoint/new/prefill',
pinpoint_request.PinpointNewPrefillRequestHandler),
('/put_entities_task', put_entities_task.PutEntitiesTaskHandler),
('/report', report.ReportHandler),
('/short_uri', short_uri.ShortUriHandler),
(r'/speed_releasing/(.*)',
speed_releasing.SpeedReleasingHandler),
('/speed_releasing', speed_releasing.SpeedReleasingHandler),
('/update_dashboard_stats',
update_dashboard_stats.UpdateDashboardStatsHandler),
('/update_test_suites', update_test_suites.UpdateTestSuitesHandler),
('/update_test_suite_descriptors',
update_test_suite_descriptors.UpdateTestSuiteDescriptorsHandler),
(oauth2_decorator.DECORATOR.callback_path,
oauth2_decorator.DECORATOR.callback_handler())
]
APP = webapp2.WSGIApplication(_URL_MAPPING, debug=False)
gae_ts_mon.initialize(APP)
from handlers.flake.detection import show_flake
from handlers.flake.reporting import component_report
from handlers.flake.reporting import flake_report
# App Engine pipeline status pages.
pipeline_status_handler_mappings = [
('/_ah/pipeline/rpc/tree', pipeline_status_ui._TreeStatusHandler),
('/_ah/pipeline/rpc/class_paths',
pipeline_status_ui._ClassPathListHandler),
('/_ah/pipeline/rpc/list', pipeline_status_ui._RootListHandler),
('/_ah/pipeline(/.+)', pipeline_status_ui._StatusUiHandler),
]
pipeline_status_application = webapp2.WSGIApplication(
pipeline_status_handler_mappings, debug=False)
if appengine_util.IsInProductionApp():
gae_ts_mon.initialize(pipeline_status_application)
# waterfall frontend.
waterfall_frontend_web_pages_handler_mappings = [
('/', home.Home),
('/waterfall/auto-revert-metrics', auto_revert_metrics.AutoRevertMetrics),
('/waterfall/check-duplicate-failures',
check_duplicate_failures.CheckDuplicateFailures),
('/waterfall/config', config.Configuration),
('/waterfall/culprit', culprit.Culprit),
('/waterfall/failure', build_failure.BuildFailure),
('/waterfall/failure-log', failure_log.FailureLog),
('/waterfall/list-failures', list_analyses.ListAnalyses),
('/waterfall/pipeline-errors-dashboard',
pipeline_errors_dashboard.PipelineErrorsDashboard),
('/waterfall/triage-suspected-cl', triage_suspected_cl.TriageSuspectedCl),
from google.appengine.api import app_identity
from handlers import flake_issues
from handlers import migrate
from handlers.all_flake_occurrences import AllFlakeOccurrences
from handlers.cron_dispatch import CronDispatch
from handlers.index import Index
from handlers.post_comment import PostComment
from handlers.search import Search
handlers = [
(r'/', Index),
(r'/post_comment', PostComment),
(r'/all_flake_occurrences', AllFlakeOccurrences),
(r'/search', Search),
(r'/cron/(.*)', CronDispatch),
(r'/issues/process/(.*)', flake_issues.ProcessIssue),
(r'/issues/update-if-stale/(.*)', flake_issues.UpdateIfStaleIssue),
(r'/issues/create_flaky_run', flake_issues.CreateFlakyRun),
(r'/override_issue_id', flake_issues.OverrideIssueId),
(r'/migrate', migrate.Migrate),
]
def is_monitoring_enabled():
return not app_identity.get_application_id().endswith('-staging')
app = webapp2.WSGIApplication(handlers, debug=True)
gae_ts_mon.initialize(app, is_enabled_fn=is_monitoring_enabled)
gae_event_mon.initialize('flakiness_pipeline')
def wrap_webapp2_app(app):
"""Instruments webapp2 application to track HTTP endpoints performance."""
gae_ts_mon.initialize(app=app,
is_enabled_fn=is_ts_monitoring_enabled,
cron_module='backend')
return app
def create_html_app(): # pragma: no cover
"""Returns WSGI app that serves HTML pages."""
app = webapp2.WSGIApplication(handlers.get_frontend_routes(),
debug=utils.is_local_dev_server())
gae_ts_mon.initialize(app, cron_module='backend')
return app
self.rows[row] = rhs.rows[row].purge_unicode()
self.category_count = sum([
len(self.ordered_categories[master])
for master in self.ordered_masters
])
num_revs = self.request.get('numrevs')
if num_revs:
num_revs = utils.clean_int(num_revs, -1)
if not num_revs or num_revs <= 0:
num_revs = 25
out = TemplateData(data, num_revs)
template = template_environment.get_template('merger_b.html')
self.response.out.write(template.render(data=out))
# Summon our persistent data model into existence.
data = MergerData()
data.bootstrap()
template_environment = jinja2.Environment()
template_environment.loader = jinja2.FileSystemLoader('templates')
template_environment.filters['notstarted'] = notstarted
URLS = [
('/restricted/merger/update', MergerUpdateAction),
('/restricted/merger/render.*', MergerRenderAction),
]
application = webapp2.WSGIApplication(URLS, debug=True)
gae_ts_mon.initialize(application)
('/migrate_test_names', migrate_test_names.MigrateTestNamesHandler),
('/deprecate_tests', deprecate_tests.DeprecateTestsHandler),
('/navbar', navbar.NavbarHandler),
('/pinpoint/new/bisect',
pinpoint_request.PinpointNewBisectRequestHandler),
('/pinpoint/new/perf_try',
pinpoint_request.PinpointNewPerfTryRequestHandler),
('/pinpoint/new/prefill',
pinpoint_request.PinpointNewPrefillRequestHandler),
('/post_bisect_results', post_bisect_results.PostBisectResultsHandler),
('/put_entities_task', put_entities_task.PutEntitiesTaskHandler),
('/report', report.ReportHandler),
('/short_uri', short_uri.ShortUriHandler),
(r'/speed_releasing/(.*)',
speed_releasing.SpeedReleasingHandler),
('/speed_releasing', speed_releasing.SpeedReleasingHandler),
('/start_try_job', start_try_job.StartBisectHandler),
('/update_bug_with_results',
update_bug_with_results.UpdateBugWithResultsHandler),
('/update_dashboard_stats',
update_dashboard_stats.UpdateDashboardStatsHandler),
('/update_test_suites', update_test_suites.UpdateTestSuitesHandler),
('/update_test_suite_descriptors',
update_test_suite_descriptors.UpdateTestSuiteDescriptorsHandler),
(oauth2_decorator.DECORATOR.callback_path,
oauth2_decorator.DECORATOR.callback_handler())
]
APP = webapp2.WSGIApplication(_URL_MAPPING, debug=False)
gae_ts_mon.initialize(APP)
from handlers import build_ahead
from handlers import calculate_confidence_scores
from handlers import check_reverted_cls
from handlers import collect_tree_closures
from handlers import obscure_emails
from handlers import process_failure_analysis_requests
from handlers import process_flake_analysis_request
from handlers.flake import update_open_flake_issues
from handlers.flake.detection import detect_flakes
from handlers.flake.detection import update_flake_counts
from handlers.flake.reporting import generate_report
# For appengine pipeline running on backend module.
pipeline_backend_application = pipeline_handlers._APP
if appengine_util.IsInProductionApp():
gae_ts_mon.initialize(pipeline_backend_application)
# "waterfall-backend" module.
waterfall_backend_web_pages_handler_mappings = [
('/waterfall/cron/calculate-confidence-scores',
calculate_confidence_scores.CalculateConfidenceScores),
('/waterfall/cron/check-reverted-cls', check_reverted_cls.CheckRevertedCLs),
('/waterfall/cron/collect-tree-closures',
collect_tree_closures.CollectTreeClosures),
('/waterfall/cron/obscure-emails', obscure_emails.ObscureEmails),
('/waterfall/cron/periodic-build-ahead', build_ahead.BuildAhead),
('/waterfall/task/process-failure-analysis-requests',
process_failure_analysis_requests.ProcessFailureAnalysisRequests),
('/waterfall/task/process-flake-analysis-request',
process_flake_analysis_request.ProcessFlakeAnalysisRequest),
]
def setUp(self):
super(TestMetrics, self).setUp()
gae_ts_mon.reset_for_unittest()
gae_ts_mon.initialize()
self.now = datetime.datetime(2016, 4, 7)
self.mock_now(self.now)
# Copyright 2019 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import webapp2
import gae_ts_mon
from gae_libs import appengine_util
from findit_v2.handlers import build_completion_processor
# "findit-backend" module.
findit_backend_handler_mappings = [
('/findit/internal/v2/task/build-completed',
build_completion_processor.BuildCompletionProcessor),
]
findit_backend_web_application = webapp2.WSGIApplication(
findit_backend_handler_mappings, debug=False)
if appengine_util.IsInProductionApp():
gae_ts_mon.initialize(findit_backend_web_application)
import gae_ts_mon
from gae_libs import appengine_util
from handlers import code_coverage
# "code-coverage-backend" module.
code_coverage_backend_handler_mappings = [
('.*/coverage/task/fetch-source-file', code_coverage.FetchSourceFile),
('.*/coverage/task/process-data/.*',
code_coverage.ProcessCodeCoverageData),
]
code_coverage_backend_web_application = webapp2.WSGIApplication(
code_coverage_backend_handler_mappings, debug=False)
if appengine_util.IsInProductionApp():
gae_ts_mon.initialize(code_coverage_backend_web_application)
# "code-coverage-frontend" module.
code_coverage_frontend_handler_mappings = [
# TODO(crbug.com/924573): Migrate to '.*/coverage/api/coverage-data'.
('/coverage/api/coverage-data', code_coverage.ServeCodeCoverageData),
# These mappings are separated so that ts_mon data (e.g. latency) is
# groupable by view. (instead of a single entry like .*/coverage.*)
('.*/coverage', code_coverage.ServeCodeCoverageData),
('.*/coverage/component', code_coverage.ServeCodeCoverageData),
('.*/coverage/dir', code_coverage.ServeCodeCoverageData),
('.*/coverage/file', code_coverage.ServeCodeCoverageData),
]
code_coverage_frontend_web_application = webapp2.WSGIApplication(
code_coverage_frontend_handler_mappings, debug=False)
if appengine_util.IsInProductionApp():
def create_html_app(): # pragma: no cover
"""Returns WSGI app that serves HTML pages."""
app = webapp2.WSGIApplication(
handlers.get_frontend_routes(), debug=utils.is_local_dev_server())
gae_ts_mon.initialize(app, cron_module='backend')
return app
import time
import threading
import urllib2
import webapp2
import gae_ts_mon
from google.appengine.api.modules import modules
metric = gae_ts_mon.CounterMetric('test/dsansome/loadtest',
description='Dummy metric for testing ts_mon on Appengine')
class IncrementHandler(webapp2.RequestHandler):
def get(self):
count = self.request.params['count']
start = time.time()
for _ in xrange(int(count)):
metric.increment()
end = time.time()
self.response.write(end - start)
main_handlers = [
(r'/inc', IncrementHandler),
]
app = webapp2.WSGIApplication(main_handlers, debug=True)
gae_ts_mon.initialize()
# TODO(hinoka): This should be in Google storage, where the grass is
# green and size limits don't exist.
compressed_result = zlib.compress(json.dumps(final_result))
if len(compressed_result) < 10**6:
cached_result = BuildLogResultModel(
url=url, version=VERSION_ID, data=compressed_result)
cached_result.put()
return final_result
else:
# Fetch the log from the buildbot master.
logging.info('Old layout')
s = BuildLog.fetch_buildlog(url)
s = s.replace('default.css', '../../static/default-old.css')
s = s.replace('<a href="stdio/text">(view as text)</a>',
'<a href="stdio/text">(view as text)</a><br/><br/>'
'<a href="%s?new=true">(New layout)</a>' %
self.request.url.split('?')[0])
return s
app = webapp2.WSGIApplication([
('/buildbot/', MainPage),
('/buildbot/(.*)/builders/(.*)/builds/(\d+)/steps/(.*)/logs/(.*)/?',
BuildLog),
('/buildbot/(.*)/builders/(.*)/builds/(\d+)/?', Build),
('/buildbot/(.*)/buildslaves/(.*)/?', BuildSlave),
('/buildbot/(.*)', BuildbotPassthrough),
])
gae_ts_mon.initialize(app)
def create_frontend_app(): # pragma: no cover
"""Returns WSGI app for frontend."""
app = webapp2.WSGIApplication(handlers.get_frontend_routes(),
debug=utils.is_local_dev_server())
gae_ts_mon.initialize(app)
return app
from frontend.handlers import triage_analysis
from frontend.handlers import uma_sampling_profiler_dashboard
from frontend.handlers import uma_sampling_profiler_result_feedback
from gae_libs.pipeline_wrapper import pipeline_status_ui
# App Engine pipeline status pages in the default module.
pipeline_status_handler_mappings = [
('/_ah/pipeline/rpc/tree', pipeline_status_ui._TreeStatusHandler),
('/_ah/pipeline/rpc/class_paths',
pipeline_status_ui._ClassPathListHandler),
('/_ah/pipeline/rpc/list', pipeline_status_ui._RootListHandler),
('/_ah/pipeline(/.+)', pipeline_status_ui._StatusUiHandler),
]
pipeline_status_application = webapp2.WSGIApplication(
pipeline_status_handler_mappings, debug=False)
gae_ts_mon.initialize(pipeline_status_application)
frontend_web_pages_handler_mappings = [
('/clusterfuzz/dashboard', clusterfuzz_dashboard.ClusterfuzzDashBoard),
('/clusterfuzz/public-dashboard',
clusterfuzz_public_dashboard.ClusterfuzzPublicDashBoard),
('/clusterfuzz/result-feedback',
clusterfuzz_result_feedback.ClusterfuzzResultFeedback),
('/clusterfuzz/triage-analysis', triage_analysis.TriageAnalysis),
('/config', crash_config.CrashConfig),
('/cracas/dashboard', cracas_dashboard.CracasDashBoard),
('/cracas/result-feedback', cracas_result_feedback.CracasResultFeedback),
('/cracas/triage-analysis', triage_analysis.TriageAnalysis),
('/uma-sampling-profiler/dashboard',
uma_sampling_profiler_dashboard.UMASamplingProfilerDashboard),
('/uma-sampling-profiler/result-feedback',
class FetchPagesAction(base_page.BasePage):
# R0201: 93,2:FetchPagesAction.get: Method could be a function
# pylint: disable=R0201
def get(self):
deferred.defer(app.fetch_pages)
class MainAction(base_page.BasePage):
def get(self):
args = self.request.query_string
self.redirect('/p/chromium/console' + '?' + args)
# Call initial bootstrap for the app module.
app.bootstrap()
base_page.bootstrap()
# GAE will cache |application| across requests if we set it here. See
# http://code.google.com/appengine/docs/python/runtime.html#App_Caching for more
# info.
application = webapp2.WSGIApplication(
[('/', MainAction),
('/p/(.*)/' + ONE_BOX_URL, OneBoxAction),
('/p/(.*)', PageAction),
('/tasks/fetch_pages', FetchPagesAction)])
gae_ts_mon.initialize(application)
from handlers import triage_suspected_cl
from handlers import try_job_dashboard
from handlers import try_job_push
from handlers import version
from handlers.flake import analyze_regression_range
from handlers.flake import check_flake
from handlers.flake import list_flakes
from handlers.flake import triage_flake_analysis
# Default module.
default_web_pages_handler_mappings = [
('/version', version.Version),
]
default_web_application = webapp2.WSGIApplication(
default_web_pages_handler_mappings, debug=False)
gae_ts_mon.initialize(default_web_application)
# Cloud Endpoint apis in the default module.
api_application = endpoints.api_server([FindItApi])
# App Engine pipeline status pages in the default module.
pipeline_status_handler_mappings = [
('/_ah/pipeline/rpc/tree', pipeline_status_ui._TreeStatusHandler),
('/_ah/pipeline/rpc/class_paths',
pipeline_status_ui._ClassPathListHandler),
('/_ah/pipeline/rpc/list', pipeline_status_ui._RootListHandler),
('/_ah/pipeline(/.+)', pipeline_status_ui._StatusUiHandler),
]
pipeline_status_application = webapp2.WSGIApplication(
pipeline_status_handler_mappings, debug=False)
gae_ts_mon.initialize(pipeline_status_application)
import webapp2
import gae_ts_mon
from backend.handlers import rerun_analyses
from backend.handlers import rerun_analysis
from backend.handlers import update_component_config
from backend.handlers import update_inverted_index
from backend.handlers import update_monorail_metrics
from backend.handlers import update_repo_to_dep_path
from gae_libs.pipeline_wrapper import pipeline_handlers
# For appengine pipeline running on backend modules.
pipeline_backend_application = pipeline_handlers._APP
gae_ts_mon.initialize(pipeline_backend_application)
backend_handler_mappings = [
('/process/update-component-config',
update_component_config.UpdateComponentConfig),
('/process/rerun-analyses', rerun_analyses.RerunAnalyses),
('/process/rerun-analysis', rerun_analysis.RerunAnalysis),
('/process/update-inverted-index',
update_inverted_index.UpdateInvertedIndex),
('/process/update-monorail-metrics',
update_monorail_metrics.UpdateMonorailMetrics),
('/process/update-repo-to-dep-path',
update_repo_to_dep_path.UpdateRepoToDepPath),
]
backend_app = webapp2.WSGIApplication(backend_handler_mappings, debug=False)
default_web_pages_handler_mappings = [
('/_ah/push-handlers/index-isolated-builds',
completed_build_pubsub_ingestor.CompletedBuildPubsubIngestor),
('/_ah/push-handlers/swarming',
swarming_pubsub_pipeline_callback.SwarmingPubSubPipelineCallback),
('/_ah/push-handlers/tryjob',
try_job_pubsub_pipeline_callback.TryJobPubSubPipelineCallback),
('/', home.Home),
# Keep this as the last one for URL redirection if there is no matching
# above and no matching in the dispatch.yaml for old urls.
(r'/.*', url_redirect.URLRedirect),
]
default_web_application = webapp2.WSGIApplication(
default_web_pages_handler_mappings, debug=False)
if appengine_util.IsInProductionApp():
gae_ts_mon.initialize(default_web_application)
# Cloud Endpoint apis in the default module.
api_application = endpoints_webapp2.api_server([FindItApi])
if appengine_util.IsInProductionApp():
gae_ts_mon.initialize(api_application)
# App Engine pipeline status pages in the default module.
# TODO(stgao): Move this to frontend module.
pipeline_status_handler_mappings = [
('/_ah/pipeline/rpc/tree', pipeline_status_ui._TreeStatusHandler),
('/_ah/pipeline/rpc/class_paths', pipeline_status_ui._ClassPathListHandler),
('/_ah/pipeline/rpc/list', pipeline_status_ui._RootListHandler),
('/_ah/pipeline(/.+)', pipeline_status_ui._StatusUiHandler),
]
pipeline_status_application = webapp2.WSGIApplication(
import threading
import urllib2
import webapp2
import gae_ts_mon
from google.appengine.api.modules import modules
metric = gae_ts_mon.CounterMetric('test/dsansome/loadtest',
'Dummy metric for testing ts_mon on Appengine',
None)
class IncrementHandler(webapp2.RequestHandler):
def get(self):
count = self.request.params['count']
start = time.time()
for _ in xrange(int(count)):
metric.increment()
end = time.time()
self.response.write(end - start)
main_handlers = [
(r'/inc', IncrementHandler),
]
app = webapp2.WSGIApplication(main_handlers, debug=True)
gae_ts_mon.initialize()
import gae_ts_mon import webapp2 from handlers.admin_dispatch import AdminDispatch from handlers.builder_timeline_data import BuilderTimelineData from handlers.index import Index from handlers.patch_status import PatchStatus from handlers.patch_summary import PatchSummary from handlers.patch_timeline import PatchTimeline from handlers.patch_timeline_data import PatchTimelineData from handlers.post import Post from handlers.stats_viewer import StatsViewer from handlers.stats_data_points import StatsDataPoints handlers = [ (r'/', Index), (r'/admin/(.*)', AdminDispatch), (r'/builder-timeline-data/(.*)/(.*)/(.*)/(.*)', BuilderTimelineData), (r'/patchset/(.*)/(.*)', PatchStatus), # Legacy URL for old links. (r'/patch-status/(.*)/(.*)', PatchStatus), (r'/patch-summary/(.*)/(.*)', PatchSummary), (r'/patch-timeline/(.*)/(.*)', PatchTimeline), (r'/patch-timeline-data/(.*)/(.*)', PatchTimelineData), (r'/post', Post), (r'/stats/(highest|lowest)/(.*)/(.*)', StatsDataPoints), (r'/stats/(.*)/(.*)', StatsViewer), ] app = webapp2.WSGIApplication(handlers, debug=True) gae_ts_mon.initialize(app)
def setUp(self): super(TestMetrics, self).setUp() gae_ts_mon.reset_for_unittest() gae_ts_mon.initialize() self.now = datetime.datetime(2016, 4, 7) self.mock_now(self.now)
