def _get_db_conn(self): if self.db and self.db.closed != 0: self.db.close() self.db = None if not self.db: # get_database config may return None or empty db_config = database.get_config() if not db_config or "DatabaseType" not in db_config: raise ValueError( "Database not set as VCAP or DATABASE_URL. Check " "documentation to see supported configuration options.") if db_config["DatabaseType"] != "PostgreSQL": raise Exception("Metrics only supports postgresql, not %s" % db_config["DatabaseType"]) host, port = self._get_db_host_and_port(db_config["DatabaseHost"]) self.db = psycopg2.connect( "options='-c statement_timeout=60s'", database=db_config["DatabaseName"], user=db_config["DatabaseUserName"], password=db_config["DatabasePassword"], host=host, port=port, connect_timeout=3, ) self.db.set_isolation_level( psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT) return self.db
def _get_database_tcp_latency(self, timeout: float = 5): db_config = database.get_config() host, port = self._get_db_host_and_port(db_config["DatabaseHost"]) # New Socket and Time out sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.settimeout(timeout) # Start a timer s_start = timer() # Try to Connect try: sock.connect((host, int(port))) sock.shutdown(socket.SHUT_RD) sock.close() # If something bad happens, the latency is None except socket.timeout: return None except OSError: return None # Stop Timer s_stop = timer() s_runtime = "%.2f" % (1000 * (s_stop - s_start)) return s_runtime
def _get_database_table_size(self): conn = self._get_db_conn() db_config = database.get_config() with conn.cursor() as cursor: cursor.execute("SELECT pg_database_size('%s');" % (db_config["DatabaseName"], )) rows = cursor.fetchall() return int_or_default(rows[0][0])
def test_inline_certs(self): self.cert_map = CertGen().cert_map c = UrlDatabaseConfiguration native_params = { c.SSLCERT: self.get_cert("postgresql.crt"), c.SSLROOTCERT: self.get_cert("root.crt"), c.SSLKEY: self.get_cert("postgresql.rsa.key"), } parts = urlparse("postgres://*****:*****@host/database") parts = parts._replace(query=urlencode(native_params)) native_url = urlunparse(parts) with mock.patch.dict(os.environ, {"DATABASE_URL": native_url}, clear=True): config = get_config() assert config assert config["DatabaseType"] == "PostgreSQL" native_params[c.SSLKEY] = self.get_cert("postgresql.pk8") jdbc_params = parse_qs(urlparse(config["DatabaseJdbcUrl"]).query) self.cmp_cert(native_params, jdbc_params, c.SSLCERT) self.cmp_cert(native_params, jdbc_params, c.SSLROOTCERT) self.cmp_cert(native_params, jdbc_params, c.SSLKEY)
def _get_database_mutations(self): conn = self._get_db_conn() db_config = database.get_config() with conn.cursor() as cursor: cursor.execute("SELECT xact_commit, " " xact_rollback, " " tup_inserted, " " tup_updated, " " tup_deleted " "FROM pg_stat_database " "WHERE datname = '%s';" % (db_config["DatabaseName"], )) rows = cursor.fetchall() return { "xact_commit": int_or_default(rows[0][0]), "xact_rollback": int_or_default(rows[0][1]), "tup_inserted": int_or_default(rows[0][2]), "tup_updated": int_or_default(rows[0][3]), "tup_deleted": int_or_default(rows[0][4]), } return None
def _set_up_environment(): if "MXRUNTIME_License.SubscriptionSecret" in os.environ: os.environ["MXUMS_SUBSCRIPTION_SECRET"] = os.environ[ "MXRUNTIME_License.SubscriptionSecret"] if "MXRUNTIME_License.LicenseServerURL" in os.environ: os.environ["MXUMS_LICENSESERVER_URL"] = os.environ[ "MXRUNTIME_License.LicenseServerURL"] if "MXRUNTIME_License.EnvironmentName" in os.environ: os.environ["MXUMS_ENVIRONMENT_NAME"] = os.environ[ "MXRUNTIME_License.EnvironmentName"] dbconfig = database.get_config() if dbconfig: os.environ[ "MXUMS_DB_CONNECTION_URL"] = "postgres://{}:{}@{}/{}".format( dbconfig["DatabaseUserName"], dbconfig["DatabasePassword"], dbconfig["DatabaseHost"], dbconfig["DatabaseName"], ) project_id = _get_project_id(os.path.join(SIDECAR_DIR, SIDECAR_CONFIG_FILE)) os.environ["MXUMS_PROJECT_ID"] = project_id e = dict(os.environ.copy()) return e
databroker.update_config(m2ee) databroker.business_events.update_config(m2ee, util.get_vcap_services_data()) # Start components and runtime telegraf.run(runtime_version) datadog.run(model_version, runtime_version) metering.run() logs.run(m2ee) runtime.run(m2ee, logs.get_loglevels()) metrics.run(m2ee) appdynamics.run() nginx.run() # Wait for the runtime to be ready before starting Databroker if databroker.is_enabled(): runtime.await_database_ready(m2ee) databroker_processes.run(database.get_config()) except RuntimeError as re: # Only the runtime throws RuntimeErrors (no pun intended) # Don't use the stack trace for these logging.error("Starting application failed: %s", re) sys.exit(1) except Exception: ex = traceback.format_exc() logging.error("Starting application failed. %s", ex) sys.exit(1) # Wait loop for runtime termination runtime.await_termination(m2ee)
def test_database_url(self): config = get_config() assert config assert config["DatabaseType"] == "PostgreSQL"
def test_invalid_jdbc_parameters(self): config = get_config() assert "tcpKeepAlive=false" not in config["DatabaseJdbcUrl"]
def test_mx_runtime_db_config(self): # Test if MXRUNTIME variables are set up if no database configuration is returned # based on DATABASE_URL or VCAP_SERVICES config = get_config() assert not config
def test_no_setup(self): with self.assertRaises(RuntimeError): get_config()
def _set_up_dd_java_agent( m2ee, model_version, runtime_version, jmx_config_files ): jar = os.path.join( SIDECAR_ROOT_DIR, os.path.basename( util.get_dependency(TRACE_AGENT_DEPENDENCY)["artifact"] ), ) # Check if already configured if 0 in [ v.find("-javaagent:{}".format(jar)) for v in util.get_javaopts(m2ee) ]: return # Inject Datadog Java agent # Add tags and explicit reserved tags util.upsert_javaopts( m2ee, [ "-javaagent:{}".format(jar), "-D{}={}".format("dd.tags", _get_datadog_tags(model_version)), "-D{}={}".format("dd.env", get_env_tag()), "-D{}={}".format("dd.service", get_service_tag()), "-D{}={}".format("dd.version", get_version_tag(model_version)), ], ) # Expllicitly set tracing flag util.upsert_javaopts( m2ee, "-D{}={}".format( "dd.trace.enabled", str(bool(_is_tracing_enabled())).lower() ), ) # Explicitly set profiling flag util.upsert_javaopts( m2ee, "-D{}={}".format( "dd.profiling.enabled", str(bool(_is_profiling_enabled(runtime_version))).lower(), ), ) # Extend with tracing options if _is_tracing_enabled(): util.upsert_javaopts( m2ee, "-D{}={}".format("dd.logs.injection", "true"), ) # Extend with database service mapping dbconfig = database.get_config() if dbconfig and "postgres" in dbconfig["DatabaseType"].lower(): util.upsert_javaopts( m2ee, "-D{}={}".format( "dd.service.mapping", "{}:{}.db".format("postgresql", get_service_tag()), ), ) # Extend with JMX options util.upsert_javaopts( m2ee, [ "-D{}={}".format("dd.jmxfetch.enabled", "true"), "-D{}={}".format("dd.jmxfetch.statsd.port", get_statsd_port()), ], ) if jmx_config_files: # Set up Java Agent JMX configuration util.upsert_javaopts( m2ee, "-D{}={}".format("dd.jmxfetch.config", ",".join(jmx_config_files)), )