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 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)
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 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()
data = {
"platform": platform.platform(),
"python": platform.python_version(),
"python_version": platform.python_implementation(),
}
return SelfDescribingJson(PLATFORM_SPEC, data)
invocation_id = str(uuid.uuid4())
platform_context = get_platform_context()
user = get_user()
subject = Subject()
subject.set_user_id(user.get("id", None))
tracker.set_subject(subject)
__is_do_not_track = False
def track(*args, **kwargs):
if __is_do_not_track:
return
else:
#logger.debug("Sending event: {}".format(kwargs))
try:
tracker.track_struct_event(*args, **kwargs)
except Exception as e:
logger.exception(
"An error was encountered while trying to send an event")
