def track(type, data): """ Called for the tracking of events input: type of event to track, data to pass output: No return """ emitter = Emitter(SNOWPLOW_MICRO_URI, buffer_size=1, on_success=success, on_failure=failure) tracker = Tracker(emitter) # Dictionary to contain all events we want to track and their corresponding methods. # So we can have a more generic way to track dict = { PAGE_VIEW: tracker.track_page_view, FORM_SUBMIT: tracker.track_form_submit, STRUCT: tracker.track_struct_event } subject = Subject() subject.set_platform("pc") tracker.set_subject(subject) if isinstance(data, list): dict[type](*data) else: dict[type](data) logger.setLevel(10)
def contact(request): title = 'Contact' form = contactForm(request.POST or None) confirm_message = None e = Emitter("192.168.2.133:8090/contact") tracker = Tracker(e, namespace="sdp", app_id="sdp-11", encode_base64=False) if form.is_valid(): name = form.cleaned_data['name'] comment = form.cleaned_data['comment'] subject = 'Message from Mysite.com' message = '%s %s' % (comment, name) emailFrom = form.cleaned_data['email'] # emailTo = [settings.EMAIL_HOST_USER] emailTo = ['*****@*****.**'] send_mail( subject, message, emailFrom, emailTo, fail_silently=True, ) title = 'Thanks!' confirm_message = 'Thanks for the message, we will get right back to you.' form = None tracker.track_page_view("192.168.2.133:8090/contact") context = { 'title': title, 'form': form, 'confirm_message': confirm_message, } template = 'contact.html' return render(request, template, context)
def listen(): print "attach" # Kafka consumer = KafkaConsumer(bootstrap_servers=os.environ["KAFKA_BOOTSTRAP_SRVS"], group_id=os.environ["KAFKA_GROUP_ID"]) consumer.subscribe([os.environ["KAFKA_SOURCE_TOPIC"]]) # Snowplow e = Emitter(os.environ["SP_COLLECTOR_URI"],protocol=os.environ["SP_COLLECTOR_PROTOCOL"],port=int(os.environ["SP_COLLECTOR_PORT"]),method=os.environ["SP_COLLECTOR_METHOD"]) t = Tracker(emitters=e,namespace="cf",app_id=str(os.environ["APP_ID"]),encode_base64=True) for msg in consumer: # try: indata = json.loads(msg.value) s1 = Subject() s1.set_platform("app") s1.set_user_id("??") s1.set_lang("??") s1.set_ip_address("0.0.0.0") s1.set_useragent("??") t.set_subject(s1) t.track_self_describing_event(SelfDescribingJson("iglu:com.snowplowanalytics.snowplow/unstruct_event/jsonschema/1-0-0",{ "data":{ "data": indata }, "schema": "iglu:"+os.environ["OPERATOR_ID"]+"/"+os.environ["APP_ID"]+"/jsonschema/1-0-0" })) t.flush() except Exception,Argument: print "Error:",str(Argument)
def setup_tracker(self): """Setup an instance of a tracker""" self.companyConfig = self.setup_config(self.companyConfig) self.emitter = Emitter(self.companyConfig["COLLECTOR_HOST"], protocol=self.companyConfig["PROTOCOL"], port=self.companyConfig["PORT"], method=self.companyConfig["EMIT_METHOD"], buffer_size=self.companyConfig["BUFFER_SIZE"]) self.subject = Subject() self.tracker = Tracker(emitters=self.emitter, subject=self.subject, namespace=self.companyConfig["TRACKER_NAME"], app_id=self.companyConfig["APP_ID"], encode_base64=self.companyConfig["ENCODE64"]) return self.tracker
def save_tweet(data): #print "save_tweet" #print data indata = data e = Emitter(args.sp_collector_uri, protocol=args.sp_collector_protocol, port=int(args.sp_collector_port), method=args.sp_collector_method) t = Tracker(emitters=e, namespace="cf", app_id=args.sp_app_id, encode_base64=True) s1 = Subject() s1.set_platform("web") s1.set_user_id(str(indata.get("user_id"))) s1.set_lang(str(indata.get("lang"))) #s1.set_ip_address(str(indata.get("i_ip"))) s1.set_useragent(str(indata.get("source"))) t.set_subject(s1) t.track_self_describing_event( SelfDescribingJson( "iglu:com.snowplowanalytics.snowplow/unstruct_event/jsonschema/1-0-0", { "data": { "data": indata }, "schema": "iglu:com.rbox24/" + args.sp_app_id + "/jsonschema/1-0-0" })) t.flush() print "Tweet sent to collector, time:", time.time()
unsent_events = [] def g(x, y): print(str(x) + " events sent successfully!") print("Events not sent. They have been stored in unsent_events:") for event_dict in y: print(event_dict) unsent_events.append(event_dict) e = Emitter(URL, buffer_size=3, on_success=f, on_failure=g) t = Tracker(e) # This doesn't cause the emitter to send a request because the buffer_size was # set to 3, not 1 t.track_page_view("http://www.myowndomainhere.dev") # This does cause the emitter to try to send all 6 events t.track_page_view("http://www.myowndomainhere.dev/signin") t.track_page_view("http://www.myowndomainhere.dev/home") t.track_page_view("http://www.myowndomainhere.dev/somepage") t.track_page_view("http://www.myowndomainhere.dev/anotherpage") t.track_page_view("http://www.myowndomainhere.dev/logout") # Since the method is GET by default, 6 separate requests are sent # If any of them are unsuccessful, they will be stored in the unsent_events # variable
print "sp_collector_protocol:", args.sp_collector_protocol print "sp_collector_port:", args.sp_collector_port print "sp_collector_method:", args.sp_collector_method print "sp_app_id:", args.sp_app_id print "--" print "Tracker setup..." #global emiter #global tracker emiter = Emitter(buffer_size=50, endpoint=args.sp_collector_uri, protocol=args.sp_collector_protocol, port=int(args.sp_collector_port), method=args.sp_collector_method) tracker = Tracker(emitters=emiter, namespace="cf", app_id=args.sp_app_id, encode_base64=True) print "Starting listening to Twitter..." #global period_counter aggregates = {} period_counter = int(time.time()) l = StdOutListener() auth = OAuthHandler(args.consumer_key, args.consumer_secret) auth.set_access_token(args.access_token, args.access_token_secret) stream = Stream(auth, l) filter_arr = args.filter.split(",") print "filter_arr:", filter_arr
def call_snowplow(request_id,json_object): # Use the global emitter and tracker dicts global e global t # callbacks are documented in # - https://github.com/snowplow/snowplow/wiki/Python-Tracker#emitters # callback for passed calls def on_success(successfully_sent_count): log("INFO","Emitter call PASSED on request_id: {}.".format(request_id)) backoff_outside_the_scope = 1 # reset the backoff if this is successful # get previous try number, choose larger of 0 or query result and add 1 try_number = max(i for i in [0,db_query("SELECT MAX(try_number) FROM caps.snowplow_calls WHERE request_id = %s ;", (request_id, ))[0]] if i is not None) + 1 log("DEBUG","Try number: {}".format(try_number)) snowplow_tuple = ( str(request_id), str(200), str(try_number), json_object['env'], json_object['namespace'], json_object['app_id'], json_object['dvce_created_tstamp'], json.dumps(json_object['event_data_json']) ) snowplow_id = db_query(snowplow_calls_sql, snowplow_tuple)[0] log("INFO","snowplow call table insertion PASSED on request_id: {} and snowplow_id: {}.".format(request_id, snowplow_id)) # callback for failed calls failed_try = 0 def on_failure(successfully_sent_count, failed_events): # increment the failed try nonlocal failed_try failed_try += 1 # sleep according to the number indexed by failed_try in the fibonacci sequence sleep_time = binets_formula(failed_try) #log("INFO","Emitter call FAILED on request_id {} on try {}. Seconds until re-attempt: {}.".format(request_id,failed_try,sleep_time)) log("INFO","Emitter call FAILED on request_id {} on try {}. No re-attempt will be made.".format(request_id,failed_try)) # Leaving this sleep delay until inputting after a failed event is ready #sleep(sleep_time) # failed_events should always contain only one event, because ASyncEmitter has a buffer size of 1 for event in failed_events: # get previous try number, choose larger of 0 or query result and add 1 # try_number = max(i for i in [0,db_query("SELECT MAX(try_number) FROM caps.snowplow_calls WHERE request_id = %s ;", (request_id, ))[0]] if i is not None) + 1 # log("DEBUG","Try number: {}".format(try_number)) snowplow_tuple = ( str(request_id), str(400), str(failed_try), json_object['env'], json_object['namespace'], json_object['app_id'], json_object['dvce_created_tstamp'], json.dumps(json_object['event_data_json']) ) snowplow_id = db_query(snowplow_calls_sql, snowplow_tuple)[0] log("INFO","snowplow call table insertion PASSED on request_id: {} and snowplow_id: {}.".format(request_id, snowplow_id)) # Re-attempt the event call by inputting it back to the emitter #e[tracker_identifier].input(event) tracker_identifier = json_object['env'] + "-" + json_object['namespace'] + "-" + json_object['app_id'] log("DEBUG","New request with tracker_identifier {}".format(tracker_identifier)) # logic to switch between SPM and Production Snowplow. # TODO: Fix SSL problem so to omit the anonymization proxy, since we connect from a Gov IP, not a personal machine sp_endpoint = os.getenv("SP_ENDPOINT_{}".format(json_object['env'].upper())) log("DEBUG","Using Snowplow Endpoint {}".format(sp_endpoint)) # Set up the emitter and tracker. If there is already one for this combination of env, namespace, and app-id, reuse it # TODO: add error checking if tracker_identifier not in e: # defaults to a GET method, defaults to a buffer size of 1; buffer is flushed once full. e[tracker_identifier] = AsyncEmitter(sp_endpoint, protocol="https", on_success=on_success, on_failure=on_failure) if tracker_identifier not in t: t[tracker_identifier] = Tracker(e[tracker_identifier], encode_base64=False, app_id=json_object['app_id'], namespace=json_object['namespace']) # Build event JSON # TODO: add error checking event = SelfDescribingJson(json_object['event_data_json']['schema'], json_object['event_data_json']['data']) # Build contexts # TODO: add error checking contexts = [] for context in json_object['event_data_json']['contexts']: contexts.append(SelfDescribingJson(context['schema'], context['data'])) # Send call to Snowplow # TODO: add error checking t[tracker_identifier].track_self_describing_event(event, contexts, tstamp=json_object['dvce_created_tstamp'])
logger = logging.getLogger(__name__) sp_logger.setLevel(100) COLLECTOR_URL = "events.fivetran.com/snowplow/forgiving_ain" COLLECTOR_PROTOCOL = "https" COOKIE_PATH = os.path.join(os.path.expanduser('~'), '.dbt/.user.yml') INVOCATION_SPEC = "https://raw.githubusercontent.com/analyst-collective/dbt/master/events/schemas/com.fishtownanalytics/invocation_event.json" PLATFORM_SPEC = "https://raw.githubusercontent.com/analyst-collective/dbt/master/events/schemas/com.fishtownanalytics/platform_context.json" RUN_MODEL_SPEC = "https://raw.githubusercontent.com/analyst-collective/dbt/master/events/schemas/com.fishtownanalytics/run_model_context.json" emitter = Emitter(COLLECTOR_URL, protocol=COLLECTOR_PROTOCOL, buffer_size=1) tracker = Tracker(emitter, namespace="cf", app_id="dbt") def __write_user(): user = {"id": str(uuid.uuid4())} cookie_dir = os.path.dirname(COOKIE_PATH) if not os.path.exists(cookie_dir): os.makedirs(cookie_dir) with open(COOKIE_PATH, "w") as fh: yaml.dump(user, fh) return user
def tracker(request): tracker = Tracker(Emitter("payments.savantdigital.net"), namespace="sdp", app_id="sdp-11", encode_base64=False) return render(request, response, context)
def create_tracker(): e = Emitter(SNOWPLOW_MICRO_URL) return Tracker(e)
], } CRED_TYPE_SYNONYMS = { "registration": "registration.registries.ca", "relationship": "relationship.registries.ca", "business_number": "relationship.registries.ca", } # Set up core Snowplow environment for api tracking SP_APP_ID = os.getenv("SP_TRACKING_APP_ID", "orgbook_api_local_dev") SP_EMITTER = AsyncEmitter(os.getenv("SP_TRACKING_EMITTER", "spm.apps.gov.bc.ca"), protocol=os.getenv("SP_TRACKING_EMITTER_PROTOCOL", "https")) SP_TRACKER = Tracker(SP_EMITTER, encode_base64=False, app_id=SP_APP_ID) LOGIN_URL = "rest_framework:login" LOGOUT_URL = "rest_framework:logout" # Internationalization # https://docs.djangoproject.com/en/1.9/topics/i18n/ LANGUAGE_CODE = "en-us" TIME_ZONE = "UTC" USE_I18N = True USE_L10N = True
"""Snowplow tracker configuration.""" import datetime import uuid from .models import Basket from snowplow_tracker import Subject, Tracker, Emitter e = Emitter("localhost:9090") t = Tracker(e) s = Subject() s.set_lang('en') """App configuration.""" CATEGORIES = [ "Electronics", "Clothes", "Shoes", "House", "Arts", ] basket = Basket()
class SnowplowManager: def __init__(self, config): """ Initialize service """ with open('src/config.json') as config_file: self.defaultConfig = json.load(config_file) self.companyConfig = config self.tracker = None self.emitter = None self.subject = None def setup_tracker(self): """Setup an instance of a tracker""" self.companyConfig = self.setup_config(self.companyConfig) self.emitter = Emitter(self.companyConfig["COLLECTOR_HOST"], protocol=self.companyConfig["PROTOCOL"], port=self.companyConfig["PORT"], method=self.companyConfig["EMIT_METHOD"], buffer_size=self.companyConfig["BUFFER_SIZE"]) self.subject = Subject() self.tracker = Tracker(emitters=self.emitter, subject=self.subject, namespace=self.companyConfig["TRACKER_NAME"], app_id=self.companyConfig["APP_ID"], encode_base64=self.companyConfig["ENCODE64"]) return self.tracker def setup_config(self, config): """Setup config with company and default config""" if config['TRACKER_NAME'] is None or \ config['APP_ID'] is None: return keys = [ 'COLLECTOR_HOST', 'PROTOCOL', 'EMIT_METHOD', 'BUFFER_SIZE', 'DEBUG_MODE', 'ENCODE64', 'PORT' ] for key in keys: config[key] = self.defaultConfig[key] if "DEV_ENV" in config: if config["DEV_ENV"] == True: config["COLLECTOR_HOST"] = self.defaultConfig[ "COLLECTOR_HOST_DEV"] if "INSPETOR_ENV" in config: if config["INSPETOR_ENV"] == True: config["COLLECTOR_HOST"] = 'test' return config def track_describing_event(self, schema, data, context, action): """ Track describing snowplow event """ self.tracker.track_self_describing_event( SelfDescribingJson(schema, data), [ SelfDescribingJson(context, {'action': action}), ], self.get_normalized_timestamp()) def track_non_describing_event(self, schema): """ Track non describing snowplow event """ self.tracker.track_self_describing_event( SelfDescribingJson( self.defaultConfig["INGRESSE_SERIALIZATION_ERROR"], {'intendedSchemaId': schema}), [], self.get_normalized_timestamp()) def flush(self): """ Flush trackers """ self.tracker.flush() def get_normalized_timestamp(self): """ Get correct timestamp """ return int(time.time()) * 1000 def get_normalized_data(self, data): """ Format string to replace non-ascii characters """ return unicodedata.normalize('NFKD', data).encode('ascii', 'ignore').decode('utf-8')
class SnowplowPlugin(Plugin): def __init__(self, vendor: str, options: SnowplowOptions) -> None: self._vendor = vendor if options.on_failure is None: options = options._replace(on_failure=self._on_failure) self._options: SnowplowOptions = options self._tracker: Optional[Tracker] = None self._logger: Logger = Logger.NONE def id(self) -> str: return 'snowplow' def load(self, options: PluginLoadOptions) -> None: self._logger = options.logger emitter = AsyncEmitter(**self._options._asdict(), ) self._tracker = Tracker(emitter) def page(self, user_id: str, category: Optional[str], name: Optional[str], properties: Optional[Properties]) -> None: assert self._tracker is not None subject = Subject() subject.set_user_id(user_id) prev_subject = self._tracker.subject try: self._tracker.set_subject(subject) self._tracker.track_screen_view(name=name) finally: self._tracker.set_subject(prev_subject) def track(self, user_id: str, event: Event) -> None: assert self._tracker is not None subject = Subject() subject.set_user_id(user_id) prev_subject = self._tracker.subject try: self._tracker.set_subject(subject) schema_version = event.version.replace(".", "-") self._tracker.track_self_describing_event( SelfDescribingJson( f'iglu:{self._vendor}/{event.id}/jsonschema/{schema_version}', event.properties.to_json())) finally: self._tracker.set_subject(prev_subject) def flush(self) -> None: assert self._tracker is not None self._tracker.flush() def shutdown(self) -> None: self.flush() def _on_failure(self, sent_count: int, unsent: Any) -> None: self._logger.error("Error. Can't send events")
def call_snowplow(request_id, json_object): '''Callback executed when an emitter is flushed successfully''' # Debugging request_id to see if it's being evaluated by the callbacks logger.info("Request ID on call_snowplow function: %s", request_id) # Use the global emitter and tracker dicts global e global t def callback_log_inscope(): logger.info("callback_log_inscope has Request ID: %s", request_id) # callbacks are documented in # - https://github.com/snowplow/snowplow/wiki/Python-Tracker#emitters # callback for passed calls def on_success(successfully_sent_count): logger.info('\'on_success\' callback with %s successful events', successfully_sent_count) callback_log_inscope() logger.info("Emitter call PASSED on request_id: %s.", request_id) # get previous try number, choose larger of 0 or query result and add 1 max_try_number_query = ("SELECT MAX(try_number) " "FROM caps.snowplow_calls " "WHERE request_id = %s ;") try_number = max(i for i in [ 0, single_response_query(max_try_number_query, (request_id, ))[0] ] if i is not None) + 1 logger.debug("Try number: %s", try_number) snowplow_tuple = (str(request_id), str(200), str(try_number), json_object['env'], json_object['namespace'], json_object['app_id'], json_object['dvce_created_tstamp'], json.dumps(json_object['event_data_json'])) snowplow_id = single_response_query(snowplow_calls_sql, snowplow_tuple)[0] logger.info( "snowplow call table insertion PASSED on " "request_id: %s and snowplow_id: %s.", request_id, snowplow_id) # callback for failed calls failed_try = 0 def on_failure(successfully_sent_count, failed_events): '''Callback executed when an emitter flush results in any failures''' # increment the failed try logger.warning( '\'on_failure\' callback: %s events successfully ' 'emitted, %s events returned by emitter with an error ' 'response', successfully_sent_count, len(failed_events)) nonlocal failed_try failed_try += 1 logger.info( 'Emitter call FAILED on request_id %s on try %s. ' 'No re-attempt will be made.', request_id, failed_try) # failed_events should always contain only one event, # because ASyncEmitter has a buffer size of 1 for event in failed_events: logger.warning('event failure: %s', event) snowplow_tuple = (str(request_id), str(400), str(failed_try), json_object['env'], json_object['namespace'], json_object['app_id'], json_object['dvce_created_tstamp'], json.dumps(json_object['event_data_json'])) snowplow_id = single_response_query(snowplow_calls_sql, snowplow_tuple)[0] logger.info( "snowplow call table insertion PASSED on request_id: " "%s and snowplow_id: %s.", request_id, snowplow_id) # Re-attempt the event call by inputting it back to the emitter tracker_identifier = "{}-{}-{}".format(json_object['env'], json_object['namespace'], json_object['app_id']) logger.debug("New request with tracker_identifier %s", tracker_identifier) # logic to switch between SPM and Production Snowplow. sp_route = os.getenv("SP_ENDPOINT_{}".format(json_object['env'].upper())) logger.debug("Using Snowplow Endpoint %s", sp_route) # Set up the emitter and tracker. If there is already one for this # combination of env, namespace, and app-id, reuse it # TODO: add error checking # TEMP COMMENTED OUT TO AVOID USING THE GLOBAL DICT OF EMITTERS/TRACKERS # if tracker_identifier not in e: # e[tracker_identifier] = AsyncEmitter( # sp_route, # protocol="https", # on_success=on_success, # on_failure=on_failure) # # if tracker_identifier not in t: # t[tracker_identifier] = Tracker( # e[tracker_identifier], # encode_base64=False, # app_id=json_object['app_id'], # namespace=json_object['namespace']) this_ASyncEmitter = AsyncEmitter(sp_route, protocol="https", on_success=on_success, on_failure=on_failure) this_Tracker = Tracker(this_ASyncEmitter, encode_base64=False, app_id=json_object['app_id'], namespace=json_object['namespace']) # Build event JSON # TODO: add error checking event = SelfDescribingJson(json_object['event_data_json']['schema'], json_object['event_data_json']['data']) # Build contexts # TODO: add error checking contexts = [] for context in json_object['event_data_json']['contexts']: contexts.append(SelfDescribingJson(context['schema'], context['data'])) # Send call to Snowplow # TODO: add error checking # TEMP COMMENTED OUT TO AVOID USING THE GLOBAL DICT OF EMITTERS/TRACKERS # t[tracker_identifier].track_self_describing_event( # event, contexts, tstamp=json_object['dvce_created_tstamp']) this_Tracker.track_self_describing_event( event, contexts, tstamp=json_object['dvce_created_tstamp'])
#See https://github.com/snowplow/snowplow/wiki/Python-Tracker # and https://github.com/snowplow-proservices/ca.bc.gov-schema-registry from snowplow_tracker import Subject, Tracker, AsyncEmitter from snowplow_tracker import SelfDescribingJson import time import random # Set up core Snowplow environment s = Subject() #.set_platform("app") e = AsyncEmitter("spm.gov.bc.ca", protocol="https") t = Tracker(e, encode_base64=False, app_id='demo') # get time stamp to create new "citizen" (be sure to convert to a string) client_id = int(time.time()) # Set some sample values for example events citizen = SelfDescribingJson('iglu:ca.bc.gov.cfmspoc/citizen/jsonschema/3-0-0', { "client_id": client_id, "service_count": 1, "quick_txn": False }) office = SelfDescribingJson('iglu:ca.bc.gov.cfmspoc/office/jsonschema/1-0-0', { "office_id": 8, "office_type": "non-reception" }) agent = SelfDescribingJson('iglu:ca.bc.gov.cfmspoc/agent/jsonschema/2-0-0', { "agent_id": 42, "role": "CSR",
"""Import Modules""" import feedparser import pprint import time import datetime import pytz from snowplow_tracker import Subject, Tracker, Emitter, SelfDescribingJson # initialze Snowplow Tracker e = Emitter("52.62.184.194:8080", protocol="http", method="post") t = Tracker(e, app_id="oneflare") s = Subject() s.set_timezone("Australia/Sydney") s.set_platform("srv") rss2 = feedparser.parse('http://www.abc.net.au/news/feed/52498/rss.xml') def getTime(getTime, tzBool): if tzBool: dt = datetime.datetime.strptime(getTime, "%a, %d %b %Y %H:%M:%S %z") dt = dt.astimezone(pytz.utc) else: dt = datetime.datetime.strptime(getTime, "%a, %d %b %Y %H:%M:%S %Z") utc_time = datetime.datetime.strftime(dt, "%Y-%m-%dT%H:%M:%SZ") return utc_time # print(getTime(rss2["entries"][0]["published"])) # rss1 = feedparser.parse('http://www.abc.net.au/news/feed/52498/rss.xml') # print rss1.modified
"channel": snowplow_channel, "program_id": svc_code, "parent_id": pgm_code, "program_name": pgm_name, "transaction_name": svc_name }) return chooseservice @staticmethod def get_finish(svc_quantity, accurate_time): inaccurate_flag = accurate_time != 1 finishservice = SelfDescribingJson( 'iglu:ca.bc.gov.cfmspoc/finish/jsonschema/1-0-0', { "inaccurate_time": inaccurate_flag, "count": svc_quantity }) return finishservice # Set up core Snowplow environment if SnowPlow.call_snowplow_flag: s = Subject() # .set_platform("app") e = AsyncEmitter(SnowPlow.sp_endpoint, on_failure=SnowPlow.failure, protocol="https") t = Tracker(e, encode_base64=False, app_id=SnowPlow.sp_appid, namespace=SnowPlow.sp_namespace)
def load(self, options: PluginLoadOptions) -> None: self._logger = options.logger emitter = AsyncEmitter(**self._options._asdict(), ) self._tracker = Tracker(emitter)
import psycopg2 import yaml import time import pytz import datetime from collections import Counter from snowplow_tracker import Subject, Tracker, Emitter, SelfDescribingJson from urllib.request import urlopen # get config file and read with open("config.yaml", 'r') as configfile: cfg = yaml.load(configfile) # initialze Snowplow Tracker e = Emitter(cfg['snpl-mini']['server'], protocol="http", method="post") t = Tracker(e, app_id="weather_info") s = Subject() s.set_timezone("Australia/Sydney") s.set_platform("srv") # Return most commin in list def most_common(lst): data = Counter(lst) return data.most_common(1)[0][0] # finding key and value searching in dic def gen_dict_extract(node, kv): if isinstance(node, list): for i in node: for x in gen_dict_extract(i, kv):
def http_get(self, payload): sp_logger.info("Sending GET request to {}...".format(self.endpoint)) sp_logger.debug("Payload: {}".format(payload)) r = requests.get(self.endpoint, params=payload, timeout=5.0) msg = "GET request finished with status code: " + str(r.status_code) if self.is_good_status_code(r.status_code): sp_logger.info(msg) else: sp_logger.warning(msg) return r emitter = TimeoutEmitter() tracker = Tracker(emitter, namespace="cf", app_id="dbt") active_user = None class User: def __init__(self, cookie_dir): self.do_not_track = True self.cookie_dir = cookie_dir self.id = None self.invocation_id = str(uuid.uuid4()) self.run_started_at = datetime.now(tz=pytz.utc) def state(self):
from flask import Flask, render_template, request, redirect from snowplow_tracker import Emitter, Tracker from snowplow_tracker import SelfDescribingJson app = Flask(__name__) email_addresses = [] e = Emitter("localhost:8080") t = Tracker(e, namespace="python", app_id="hello_bears") @app.route('/emails', methods=['GET']) def emails(): t.track_self_describing_event( SelfDescribingJson( "iglu:com.hellobears/email_addresses_viewed/jsonschema/1-0-0", {"test": "stewart"})) return render_template('emails.html', email_addresses=email_addresses) @app.route('/signup', methods=['POST']) def signup(): email = request.form['email'] email_addresses.append(email) t.track_self_describing_event( SelfDescribingJson( "iglu:com.hellobears/email_address_submitted/jsonschema/1-0-0", {"email_address": email})) return redirect('/')