def run(dateRange, schema_file):
profile = get_instance_profile()
ms = load_schema(schema_file, profile.visibility)
sm = ScheduleManager(ms, dataPointFactory)
logging.info("INST Started")
if profile.visibility:
sm.collect(dateRange)
sleep(5)
sm.send(dateRange)
logging.info("INST Done")
def __init__(self,
splunkrc=None,
deploymentID=None,
schema=None,
factory=None,
send_data=None,
send_log=None,
instance_profile=None,
quick_draw=None):
self._splunkrc = splunkrc
self.deploymentID = deploymentID
self.transaction_id = None
if not instance_profile:
self.instance_profile = get_instance_profile(self._splunkrc)
else:
self.instance_profile = instance_profile
if not schema:
schema = metrics_schema.load_schema(
INST_SCHEMA_FILE, visibility=self.instance_profile.visibility)
self.schema = schema
if not factory:
factory = dataPointFactory
self.factory = factory
self.deliverySchema = self.schema.delivery
if not quick_draw:
qd = get_quick_draw()
else:
qd = quick_draw
if qd:
self.deliverySchema.url = qd.get('url')
self.transaction_id = self.get_transactionID()
if not send_data:
self.sd = SendData(
deploymentID=self.instance_profile.get_deployment_id(),
deliverySchema=self.deliverySchema,
transaction_id=self.get_transactionID())
else:
self.sd = send_data
if not send_log:
self.sl = SendLog(splunkrc=self._splunkrc)
else:
self.sl = send_log
self.result = None
self.is_cloud = self.instance_profile.server_is_cloud
def run_phase_1_for_all_nodes(dateRange, schema_file):
'''
phase 1 runs by all nodes to collect role based data and index to data to _introspection
phase 1 does not check opt in options
:param profile
:param dateRange
:param schema_file
:return: None
'''
report.report('Running_Phase[]', 1)
ms = load_schema(schema_file, '*')
sm = ScheduleManager(ms, dataPointFactory)
# to add phase 1 and ignore visibility
sm.phase_1(dateRange, INTROSPECTION_INDEX_NAME)
def run_phase_2(profile, dateRange, schema_file):
'''
phase 2 runs by lead node only and only runs when a deployment is opted in.
sm.phase_2() does the following:
- collects and indexes data points marked as phase = 2
- query data collected by phase = 1 and phase = 2 and send the data to splunkx
:param profile
:param dateRange
:param schema_file
:return: None
'''
report.report('Running_Phase[]', 2)
ms = load_schema(schema_file, profile.visibility)
sm = ScheduleManager(ms, dataPointFactory)
sleep(5)
sm.phase_2(dateRange, INTROSPECTION_INDEX_NAME)
def __init__(self, command_line=None, command_arg=None):
PersistentServerConnectionApplication.__init__(self)
self.DTO_FIELD = [
'timestamp',
'deploymentID',
'eventID',
'experienceID',
'component',
'userID',
'visibility',
'data'
]
self.DTO_DEFAULT_VALUE = {
"timestamp": lambda event: int(time.time()),
"deploymentID": self.getDeploymentID,
"userID": self.getUserID,
"visibility": lambda event: ANONYMOUS,
"eventID": lambda event: str(uuid.uuid4())
}
self.FIELD_TYPE = {
"userID": [str, unicode],
"eventID": [str, unicode],
"experienceID": [str, unicode],
"timestamp": [int],
"data": [dict],
"component": [str, unicode]
}
self.FIELD_NAME = {
str: 'string',
unicode: 'string',
int: 'integer',
dict: 'JSON Object'
}
self.schema = metrics_schema.load_schema(INST_SCHEMA_FILE)
self.qd = get_quick_draw()
self.deliverySchema = self.schema.delivery
self.deliverySchema.url = self.qd.get('url')
self.deploymentID = ''
self.token = ''
self.server_uri = ''
self.userID = ''
class SwaContext(object):
'''
Encapsulates all of the contextual data
needed to render the SWA initialization script.
'''
salt = None
deployment_id = ''
send_anonymized_web_analytics = False
opt_in_is_up_to_date = False
user_id = ''
swa_base_url = False
schema = load_schema(INST_SCHEMA_FILE)
server_uri = rest.makeSplunkdUri()
# Defer cds_url until we know that there has been opt-in for SWA.
# See SPL-141718 [Splunkweb Appserver may take a long time to start due to
# SWA/splunk_instrumentation] for more details.
cds_url = None
instance_guid = ''
visibility = ''
def should_load_swajs(self):
'''
Returns true if the telemetry conf file idicates we should be
instrumentation the UI.
'''
return self.send_anonymized_web_analytics and self.opt_in_is_up_to_date
def to_dict(self):
'''
Returns the configuration items from this object in a dictionary.
'''
swa_js_url = routes.make_route(
'/static/app/splunk_instrumentation/build/pages/swa.js')
result = {
'swa_js_url': swa_js_url,
'options': {
'deploymentID': self.deployment_id,
'userID': self.user_id,
'version': self.schema.delivery.version,
'instanceGUID': self.instance_guid,
'visibility': self.visibility,
}
}
if self.swa_base_url:
result['options']['url'] = routes.make_route(self.swa_base_url)
result['options']['bundleDataFunction'] = 'json'
else:
result['options']['url'] = self.cds_url
return result
def update(self,
cherrypy,
services=None,
deployment_id_manager=None,
salt_manager=None):
'''
Updates the volatile data members of the swa context.
This method is hit each time an HTML page is hit, so the
less work done here the better.
'''
if services is None:
splunkd = Splunkd(token=cherrypy.session.get('sessionKey'),
server_uri=self.server_uri)
telemetry_conf_service = TelemetryConfService(splunkd,
is_read_only=True)
telemetry_conf_service.fetch()
# Specialize the telemetry_conf_service to be read only up front,
# use the default construction for other services.
services = ServiceBundle(
splunkd, telemetry_conf_service=telemetry_conf_service)
if not self.instance_guid:
self.instance_guid = services.server_info_service.content.get(
'guid')
salt_manager = salt_manager or SaltManager(services)
self.salt = salt_manager.get_salt()
deployment_id_manager = deployment_id_manager or DeploymentIdManager(
splunkd, telemetry_conf_service=services.telemetry_conf_service)
self.deployment_id = deployment_id_manager.get_deployment_id() or ''
self.opt_in_is_up_to_date = services.telemetry_conf_service.opt_in_is_up_to_date(
)
self.swa_base_url = services.telemetry_conf_service.content.get(
'swaEndpoint')
hash_key = self.salt + splunk.auth.getCurrentUser()['name']
if sys.version_info >= (3, 0):
hash_key = hash_key.encode()
self.user_id = hashlib.sha256(hash_key).hexdigest()
self.send_anonymized_web_analytics = conf_bool(
services.telemetry_conf_service.content.get(
'sendAnonymizedWebAnalytics'))
visibilities = []
if services.server_info_service.is_cloud():
visibilities = ['anonymous', 'support']
else:
if conf_bool(
services.telemetry_conf_service.content.get(
'sendAnonymizedUsage')):
visibilities.append('anonymous')
if conf_bool(
services.telemetry_conf_service.content.get(
'sendSupportUsage')):
visibilities.append('support')
self.visibility = ','.join(visibilities)
if self.send_anonymized_web_analytics and not self.cds_url:
self.cds_url = get_quick_draw().get('url')
