def test_request(self):
from pyga.requests import Tracker, Visitor, Session, Page
from mock import Mock
mocked = six.moves.urllib.request.urlopen = Mock()
meta = dict(
REMOTE_ADDR='134.321.0.1',
HTTP_USER_AGENT='Test User Agent 1.0',
HTTP_ACCEPT_LANGUAGE='en-US,en;q=0.8,ru;q=0.6',
)
tracker = Tracker('UA-0000-0000', 'test.com')
visitor = Visitor()
visitor.extract_from_server_meta(meta)
self.assertEqual(visitor.ip_address, '134.321.0.1')
self.assertEqual(visitor.locale, 'en_US')
self.assertEqual(visitor.user_agent, 'Test User Agent 1.0')
session = Session()
page = Page('/test_path')
tracker.track_pageview(page, session, visitor)
(request, ), _ = mocked.call_args_list.pop()
self.assertEqual(request.headers.get('X-forwarded-for'), '134.321.0.1')
self.assertEqual(request.headers.get('User-agent'), 'Test User Agent 1.0')
# Assert that &ua and &uip are passed along, and that &uip is properly
# anonymized.
qs = six.moves.urllib.parse.urlparse(request.get_full_url()).query
params = six.moves.urllib.parse.parse_qs(qs)
self.assertEqual(params['uip'][0], '134.321.0.0')
self.assertEqual(params['ua'][0], 'Test User Agent 1.0')
def test_request(self):
from pyga.requests import Tracker, Visitor, Session, Page
from mock import Mock
import urllib2
mocked = urllib2.urlopen = Mock()
meta = dict(
REMOTE_ADDR='134.321.0.1',
HTTP_USER_AGENT='Test User Agent 1.0',
HTTP_ACCEPT_LANGUAGE='en-US,en;q=0.8,ru;q=0.6',
)
tracker = Tracker('UA-0000-0000', 'test.com')
visitor = Visitor()
visitor.extract_from_server_meta(meta)
self.assertEqual(visitor.ip_address, '134.321.0.1')
self.assertEqual(visitor.locale, 'en_US')
self.assertEqual(visitor.user_agent, 'Test User Agent 1.0')
session = Session()
page = Page('/test_path')
tracker.track_pageview(page, session, visitor)
(request, ), _ = mocked.call_args_list.pop()
self.assertEqual(request.headers.get('X-forwarded-for'), '134.321.0.1')
self.assertEqual(request.headers.get('User-agent'),
'Test User Agent 1.0')
def register_event(page): tracker = Tracker(GA_TRACKER, DOMAIN) visitor = Visitor() visitor.extract_from_server_meta(request.environ) session = Session() page = Page(page) tracker.track_pageview(page, session, visitor)
def track_validate(valid=True):
value = 1 if valid else 0
tracker = Tracker(account_id='UA-7385360-18', domain_name='geojsonlint.com')
event = Event(category='server', action='validate', value=value)
session = Session()
visitor = Visitor()
tracker.track_event(event, session, visitor)
def test_request(self):
from pyga.requests import Tracker, Visitor, Session, Page
from mock import Mock
from urlparse import urlparse, parse_qs
import urllib2
mocked = urllib2.urlopen = Mock()
meta = dict(
REMOTE_ADDR='134.321.0.1',
HTTP_USER_AGENT='Test User Agent 1.0',
HTTP_ACCEPT_LANGUAGE='en-US,en;q=0.8,ru;q=0.6',
)
tracker = Tracker('UA-0000-0000', 'test.com')
visitor = Visitor()
visitor.extract_from_server_meta(meta)
self.assertEqual(visitor.ip_address, '134.321.0.1')
self.assertEqual(visitor.locale, 'en_US')
self.assertEqual(visitor.user_agent, 'Test User Agent 1.0')
session = Session()
page = Page('/test_path')
tracker.track_pageview(page, session, visitor)
(request, ), _ = mocked.call_args_list.pop()
self.assertEqual(request.headers.get('X-forwarded-for'), '134.321.0.1')
self.assertEqual(request.headers.get('User-agent'), 'Test User Agent 1.0')
# Assert that &ua and &uip are passed along, and that &uip is properly
# anonymized.
qs = urlparse(request.get_full_url()).query
params = parse_qs(qs)
self.assertEqual(params['uip'][0], '134.321.0.0')
self.assertEqual(params['ua'][0], 'Test User Agent 1.0')
def test_request(self, mocked):
from pyga.requests import Tracker, Visitor, Session, Page
meta = dict(
REMOTE_ADDR="134.321.0.1",
HTTP_USER_AGENT="Test User Agent 1.0",
HTTP_ACCEPT_LANGUAGE="en-US,en;q=0.8,ru;q=0.6",
)
tracker = Tracker("UA-0000-0000", "test.com")
visitor = Visitor()
visitor.extract_from_server_meta(meta)
self.assertEqual(visitor.ip_address, "134.321.0.1")
self.assertEqual(visitor.locale, "en_US")
self.assertEqual(visitor.user_agent, "Test User Agent 1.0")
session = Session()
page = Page("/test_path")
tracker.track_pageview(page, session, visitor)
(request, ), _ = mocked.call_args_list.pop()
self.assertEqual(request.headers.get("X-forwarded-for"), "134.321.0.1")
self.assertEqual(request.headers.get("User-agent"),
"Test User Agent 1.0")
# Assert that &ua and &uip are passed along, and that &uip is properly
# anonymized.
qs = urlparse(request.get_full_url()).query
params = parse_qs(qs)
self.assertEqual(params["uip"][0], "134.321.0.0")
self.assertEqual(params["ua"][0], "Test User Agent 1.0")
def test_request(self, mocked):
from pyga.requests import Tracker, Visitor, Session, Page
meta = dict(
REMOTE_ADDR="134.321.0.1",
HTTP_USER_AGENT="Test User Agent 1.0",
HTTP_ACCEPT_LANGUAGE="en-US,en;q=0.8,ru;q=0.6",
)
tracker = Tracker("UA-0000-0000", "test.com")
visitor = Visitor()
visitor.extract_from_server_meta(meta)
self.assertEqual(visitor.ip_address, "134.321.0.1")
self.assertEqual(visitor.locale, "en_US")
self.assertEqual(visitor.user_agent, "Test User Agent 1.0")
session = Session()
page = Page("/test_path")
tracker.track_pageview(page, session, visitor)
(request,), _ = mocked.call_args_list.pop()
self.assertEqual(request.headers.get("X-forwarded-for"), "134.321.0.1")
self.assertEqual(
request.headers.get("User-agent"), "Test User Agent 1.0"
)
# Assert that &ua and &uip are passed along, and that &uip is properly
# anonymized.
qs = urlparse(request.get_full_url()).query
params = parse_qs(qs)
self.assertEqual(params["uip"][0], "134.321.0.0")
self.assertEqual(params["ua"][0], "Test User Agent 1.0")
def track_page(path):
tracker = Tracker(GA_ACCOUNT_CODE.replace('UA-', 'MO-'), MOCO_URL)
visitor = Visitor()
# visitor.ip_address = '194.54.176.12'
session = Session()
page = Page(path)
tracker.track_pageview(page, session, visitor)
def get(self, request, path=None, **resources):
""" Proxy request to GA. """
tracker = Tracker(self._meta.account_id, self._meta.domain or request.META.get("SERVER_NAME"))
visitor = Visitor()
visitor.extract_from_server_meta(request.META)
session = Session()
page = Page(path)
tracker.track_pageview(page, session, visitor)
def get(self, request, path=None, **resources):
""" Proxy request to GA. """
tracker = Tracker(self._meta.account_id, self._meta.domain
or request.META.get('SERVER_NAME'))
visitor = Visitor()
visitor.extract_from_server_meta(request.META)
session = Session()
page = Page(path)
tracker.track_pageview(page, session, visitor)
def send(self, identity, properties, aliases, events, request_meta):
host_name = (request_meta.get('HTTP_HOST') or
Site.objects.get_current().domain)
tracker = Tracker(self.web_id, host_name)
visitor = Visitor()
visitor.unique_id = abs(hash(identity)) >> 33
visitor.extract_from_server_meta(request_meta)
session = Session()
for event_name, event_properties in events:
event = Event(category=self.event_category, action=event_name)
tracker.track_event(event, session, visitor)
def add_event(self, user_source):
ga_tracker = Tracker(account_id='UA-162032901-2',
domain_name='test.picasix.com')
event = Event(category='UserEvents',
action='Visit',
label='User' + str(user_source),
value=1)
session = Session()
visitor = Visitor()
ga_tracker.track_event(event=event, session=session, visitor=visitor)
return "event added"
class Analytics(object):
"""
This is a wrapper for Google Analytics tracking code.
All interaction with GA should be asynchronous so that the main code is not
delayed.
"""
def __init__(self, account_id=None, domain_name=None):
self.account_id = account_id
self.domain_name = domain_name
def __repr__(self):
return "Analytics(account_id='{account_id}', domain_name='{domain_name}')".\
format(account_id=self.account_id, domain_name=self.domain_name)
def start_session(self, caller_id):
self.caller_id = caller_id
if self.account_id:
self.tracker = Tracker(self.account_id, self.domain_name)
self.visitor = Visitor()
self.visitor.user_agent = self.caller_id
self.visitor.unique_id = hash(caller_id) & 0x7fffffff
# print self.visitor.unique_id
# print self.visitor.__getstate__()
self.session = Session()
@async
def track_pageview(self, page):
try:
if self.account_id:
self.tracker.track_pageview(Page(page), self.session,
self.visitor)
except:
print ('Uncaught exception in Analytics process: \n'
+ unicode(traceback.format_exc(), 'utf8'))
@async
def track_event(self, category=None, action=None, label=None, value=None):
try:
if self.account_id:
if label is None:
label = self.caller_id
self.tracker.track_event(Event(category, action, label, value),
self.session, self.visitor)
except:
print ('Uncaught exception in Analytics process: \n'
+ unicode(traceback.format_exc(), 'utf8'))
class Analytics(object):
"""
This is a wrapper for Google Analytics tracking code.
All interaction with GA should be asynchronous so that the main code is not
delayed.
"""
def __init__(self, account_id=None, domain_name=None):
self.account_id = account_id
self.domain_name = domain_name
def __repr__(self):
return "Analytics(account_id='{account_id}', domain_name='{domain_name}')".\
format(account_id=self.account_id, domain_name=self.domain_name)
def start_session(self, caller_id):
self.caller_id = caller_id
if self.account_id:
self.tracker = Tracker(self.account_id, self.domain_name)
self.visitor = Visitor()
self.visitor.user_agent = self.caller_id
self.visitor.unique_id = hash(caller_id) & 0x7fffffff
# print self.visitor.unique_id
# print self.visitor.__getstate__()
self.session = Session()
@async
def track_pageview(self, page):
try:
if self.account_id:
self.tracker.track_pageview(Page(page), self.session,
self.visitor)
except:
print('Uncaught exception in Analytics process: \n' +
unicode(traceback.format_exc(), 'utf8'))
@async
def track_event(self, category=None, action=None, label=None, value=None):
try:
if self.account_id:
if label is None:
label = self.caller_id
self.tracker.track_event(Event(category, action, label, value),
self.session, self.visitor)
except:
print('Uncaught exception in Analytics process: \n' +
unicode(traceback.format_exc(), 'utf8'))
def ping():
"""ping back to ga"""
if not ga_account:
return
tracker = Tracker(ga_account, ga_domain)
visitor = Visitor()
visitor.ip_address = request.remote_addr
session = Session()
page = Page(request.path)
if 'referer' in request.headers:
page.referrer = request.headers['referer']
tracker.track_pageview(page, session, visitor)
def ping():
"""ping back to ga"""
if not ga_account:
return
tracker = Tracker(ga_account, ga_domain)
visitor = Visitor()
visitor.ip_address = request.remote_addr
session = Session()
page = Page(request.path)
if "referer" in request.headers:
page.referrer = request.headers["referer"]
tracker.track_pageview(page, session, visitor)
def process_request(self, request):
if settings.GA_ENABLED:
ip = request.META["REMOTE_ADDR"]
if request.META.has_key("CF-Connecting-IP"):
ip = request.META["CF-Connecting-IP"]
tracker = Tracker(settings.GA_KEY, request.META["HTTP_HOST"])
visitor = Visitor()
visitor.ip_address = ip
session = Session()
page = Page(request.path)
tracker.track_pageview(page, session, visitor)
return None
def track_validate(valid=True):
try:
#
# This is just a nice-to-have. Do not fail tests or bail on the request
# for anything that goes wrong here.
#
value = 1 if valid else 0
tracker = Tracker(account_id="UA-7385360-18", domain_name="geojsonlint.com")
event = Event(category="server", action="validate", value=value)
session = Session()
visitor = Visitor()
tracker.track_event(event, session, visitor)
except:
pass
def process_request(self, request):
if settings.GA_ENABLED:
ip = request.META["REMOTE_ADDR"]
if request.META.has_key("CF-Connecting-IP"):
ip = request.META["CF-Connecting-IP"]
tracker = Tracker(settings.GA_KEY, request.META["HTTP_HOST"])
visitor = Visitor()
visitor.ip_address = ip
session = Session()
page = Page(request.path)
tracker.track_pageview(page, session, visitor)
return None
def start_session(self, caller_id):
self.caller_id = caller_id
if self.account_id:
self.tracker = Tracker(self.account_id, self.domain_name)
self.visitor = Visitor()
self.visitor.user_agent = self.caller_id
self.visitor.unique_id = hash(caller_id) & 0x7fffffff
# print self.visitor.unique_id
# print self.visitor.__getstate__()
self.session = Session()
def track_validate(valid=True):
try:
#
# This is just a nice-to-have. Do not fail tests or bail on the request
# for anything that goes wrong here.
#
value = 1 if valid else 0
tracker = Tracker(account_id='UA-7385360-18', domain_name='geojsonlint.com')
event = Event(category='server', action='validate', value=value)
session = Session()
visitor = Visitor()
tracker.track_event(event, session, visitor)
except:
pass
def alloc_ga_obj_by_name(name):
"""
通过名字生成对应的obj
"""
from pyga.requests import Tracker, Page, Session, Visitor, Transaction, Event, SocialInteraction, Campaign
obj = None
if name == 'tracker':
obj = Tracker()
elif name == 'campaign':
obj = Campaign(Campaign.TYPE_REFERRAL)
elif name == 'session':
obj = Session()
elif name == 'page':
obj = Page(None)
elif name == 'visitor':
obj = Visitor()
elif name == 'transaction':
obj = Transaction()
elif name == 'event':
obj = Event()
elif name == 'social_interaction':
obj = SocialInteraction()
return obj
def middleware(request):
if ga_id is not False:
tracker = Tracker(ga_id, request.headers['Host'])
visitor = Visitor()
visitor.ip_address = request.META.get('REMOTE_ADDR')
if request.headers['User-Agent']:
visitor.user_agent = request.headers['User-Agent']
session = Session()
path = request.path
if request.META.get('QUERY_STRING'):
path = f"{request.path}?{request.META.get('QUERY_STRING')}"
page = Page(path)
page.title = request.path
tracker.track_pageview(page, session, visitor)
response = get_response(request)
return response
def log_traffic(request):
if not google_analytics:
return
url = urlparse(request.base_url)
pyga_tracker = Tracker(google_analytics, url.hostname)
pyga_visitor = Visitor()
pyga_visitor.ip_address = request.access_route[0]
pyga_visitor.user_agent = request.headers.get('User-Agent')
user_locals = []
if 'Accept-Language' in request.headers:
al = request.headers.get('Accept-Language')
if al is not None:
matched_locales = utils.validate_locale(al)
if matched_locales:
lang_lst = map((lambda x: x.replace('-', '_')),
(i[1] for i in matched_locales))
quality_lst = map(
(lambda x: x and x or 1),
(float(i[4] and i[4] or '0') for i in matched_locales))
lang_quality_map = map((lambda x, y: (x, y)), lang_lst,
quality_lst)
user_locals = [
x[0] for x in sorted(
lang_quality_map, key=itemgetter(1), reverse=True)
]
if user_locals:
pyga_visitor.locale = user_locals[0]
pyga_session = Session()
pyga_page = Page(url.path)
pyga_page.referrer = request.headers.get('Referer')
logger.info('Logging GA traffic from %s to host %s with page %s',
pyga_visitor.ip_address, url.hostname, url.path)
try:
pyga_tracker.track_pageview(pyga_page, pyga_session, pyga_visitor)
except URLError:
logger.warn('Unable to connect to analytics')
except:
logger.error('Analytics logging failed')
logger.error(sys.exc_info())
def get_ga():
from pyga.requests import Tracker, Session, Config
with plugin.get_storage("analytics") as ga:
config = Config()
tracker = Tracker(TRACKING_ID, 'steeve.io', conf=config)
session = ga.setdefault("session", Session())
if not ga.get("visitor"):
ga["visitor"] = make_visitor()
return tracker, session, ga["visitor"]
def on_order_paid(order, payment, request, **kwargs):
if not request:
return
ga_data = order.data.get("google_analytics", {})
tracker = Tracker(settings.GOOGLE_ANALYTICS_ID, request.get_host())
# create visitor
visitor = Visitor()
try:
visitor.extract_from_utma(ga_data.get("utma", ""))
except ValueError:
return # utma cookie value is invalid
visitor.extract_from_server_meta(ga_data.get("meta", {}))
# create session
session = Session()
try:
session.extract_from_utmb(ga_data.get("utmb", ""))
except ValueError:
return # utmb cookie value is invalid
# create transaction
transaction = Transaction()
transaction.order_id = order.order_id
transaction.total = order.subtotal
transaction.tax = order.tax
transaction.shipping = order.shipping
transaction.city = order.billing_city.encode("utf8")
transaction.country = ("%s" % order.billing_country).encode("utf8")
transaction.currency = order.currency
for item in order.items.all():
i = Item()
i.sku = item.sku
i.name = item.name.encode("utf8")
i.price = item.unit_price
i.quantity = item.quantity
transaction.add_item(i)
# tracker.setcurrencyCode
tracker.track_transaction(transaction, session, visitor)
order.data["google_analytics"]["tracked"] = now()
order.save()
def get_ga():
from pyga.requests import Tracker, Session, Config
ga = plugin.get_storage("analytics")
config = Config()
config.anonimize_ip_address = True
tracker = Tracker(TRACKING_ID, 'steeve.io', conf=config)
session = ga.setdefault("session", Session())
visitor = ensure_screen_res(ga.setdefault("visitor", make_visitor()))
return tracker, session, visitor
def get_ga_tracker(self, GOOGLE_ANALYTICS_CODE=GA_CODE, GOOGLE_ANALYTICS_SITE=GA_SITE, *args, **kwargs):
"""
Creates a tracker and fills it with session and visitor, optionally matched with given user if user_id is provided
Returns self for convenient use of other wrapped functions
Pass force=True in to re-initiate the tracker
"""
if not hasattr(self, 'ga_tracker') or 'force' in kwargs:
self.ga_tracker = Tracker(GOOGLE_ANALYTICS_CODE, GOOGLE_ANALYTICS_SITE)
self.get_ga_session(**kwargs)
self.get_ga_visitor(**kwargs)
return self
def track_event(category=None, action=None, label=None, value=None, identifier=None, first_use=None, add=None,
noninteraction=True):
anonymousConfig = Config()
anonymousConfig.anonimize_ip_address = True
tracker = Tracker('UA-86466078-1', 'none', conf=anonymousConfig)
visitor = Visitor()
# convert the last 8 bytes of the machine identifier to an integer to get a "unique" user
visitor.unique_id = struct.unpack("!I", binascii.unhexlify(identifier[32:]))[0]/2
if add:
# add visitor's ip address (will be anonymized)
visitor.ip_address = add
if first_use:
visitor.first_visit_time = first_use
session = Session()
event = Event(category=category, action=action, label=label, value=value, noninteraction=noninteraction)
path = u"/" + u"/".join([category, action, label])
page = Page(path.lower())
tracker.track_event(event, session, visitor)
tracker.track_pageview(page, session, visitor)
def deliver(cls, entry):
now = datetime.utcnow()
# make the call to google analytics
tracker = Tracker(entry['gacode'], entry['domain'])
visitor = Visitor(entry)
# possible other data:
#visitor.flash_version = None
#visitor.java_enabled = None
#visitor.screen_colour_depth = None
#visitor.screen_resolution = None
session = Session()
page = Page(entry['path'])
page.referer = entry['referer']
page.title = entry['title']
#page.charset = entry['charset']
#page.load_time = entry['load_time']
tracker.track_pageview(page, session, visitor)
def ping():
from pyga.requests import Tracker, Event, Session, Visitor
upc = request.args.get('upc')
query = Consumable.query.filter_by(upc=upc)
consumable = query.first()
if consumable is not None:
consumable_name = consumable.name
group = BeverageGroup.query.filter_by(id=consumable.beverage_group_id).first()
if group:
group_name = group.name
else:
group_name = 'Unknown'
else:
consumable_name = upc
group_name = 'Unknown'
tracker = Tracker('UA-5298189-10', 'beverages.cw')
event_label = "{0}: {1}".format(group_name, consumable_name)
event = Event('Beverage Fridge', 'Drink', event_label, 1)
session = Session()
visitor = Visitor()
tracker.track_event(event, session, visitor)
return render_template(
'ping.html',
upc=upc,
name=consumable_name,
group=group_name
)
def start_session(self, caller_id):
self.caller_id = caller_id
if self.account_id:
self.tracker = Tracker(self.account_id, self.domain_name)
self.visitor = Visitor()
self.visitor.user_agent = self.caller_id
self.visitor.unique_id = hash(caller_id) & 0x7fffffff
# print self.visitor.unique_id
# print self.visitor.__getstate__()
self.session = Session()
def ga_track(self, event={}):
_req_list = []
no_tracking = self.get_argument('no_tracking', None)
is_prod = getattr(config, 'RUN_IN_PROD', False)
if not no_tracking and is_prod and hasattr(config, "GA_ACCOUNT"):
_req = self.request
remote_ip = _req.headers.get("X-Real-Ip",
_req.headers.get("X-Forwarded-For",
_req.remote_ip))
user_agent = _req.headers.get("User-Agent", None)
visitor = Visitor()
visitor.ip_address = remote_ip
visitor.user_agent = user_agent
#get visitor.locale
visitor.extract_from_server_meta(
{"HTTP_ACCEPT_LANGUAGE": _req.headers.get("Accept-Language", None)}
)
session = Session()
page = Page(_req.path)
tracker = Tracker(config.GA_ACCOUNT, 'MyVariant.info')
# tracker.track_pageview(page, session, visitor) #this is non-async request
pvr = PageViewRequest(config=tracker.config,
tracker=tracker,
visitor=visitor,
session=session,
page=page)
r = pvr.build_http_request()
_req_list.append(HTTPRequest(r.get_full_url(),
"POST" if (r.data) else "GET",
headers=r.headers,
body=r.data))
if event:
evt = Event(**event)
#tracker.track_event(evt, session, visitor) #this is non-async request
er = EventRequest(config=tracker.config,
tracker=tracker,
visitor=visitor,
session=session,
event=evt)
r = er.build_http_request()
_req_list.append(HTTPRequest(r.get_full_url(),
"POST" if (r.data) else "GET",
headers=r.headers,
body=r.data))
#now send actual async requests
http_client = AsyncHTTPClient()
for _req in _req_list:
http_client.fetch(_req)
def test_request(self):
from pyga.requests import Tracker, Visitor, Session, Page
from mock import Mock
import urllib2
mocked = urllib2.urlopen = Mock()
meta = dict(
REMOTE_ADDR='134.321.0.1',
HTTP_USER_AGENT='Test User Agent 1.0',
HTTP_ACCEPT_LANGUAGE='en-US,en;q=0.8,ru;q=0.6',
)
tracker = Tracker('UA-0000-0000', 'test.com')
visitor = Visitor()
visitor.extract_from_server_meta(meta)
self.assertEqual(visitor.ip_address, '134.321.0.1')
self.assertEqual(visitor.locale, 'en_US')
self.assertEqual(visitor.user_agent, 'Test User Agent 1.0')
session = Session()
page = Page('/test_path')
tracker.track_pageview(page, session, visitor)
(request, ), _ = mocked.call_args_list.pop()
self.assertEqual(request.headers.get('X-forwarded-for'), '134.321.0.1')
self.assertEqual(request.headers.get('User-agent'), 'Test User Agent 1.0')
#!/usr/bin/python
from pyga.requests import Tracker, Page, Session, Visitor
import random
import time
tracker = Tracker('UA-7848481-1', 'apocalypsebag.com')
quant = random.randint(10, 100)
ips = ['46.21.16.10', '5.83.240.190', '31.6.128.445', '58.99.64.32', '49.128.32.22']
cnt = 1
while cnt < quant:
ip = ips[random.randint(0, 4)]
uri = '/'
#print "page request %d of %d for %s from %s" % (cnt, quant, uri, ip)
visitor = Visitor()
visitor.ip_address = ip
session = Session()
page = Page(uri)
tracker.track_pageview(page, session, visitor)
cnt += 1
time.sleep(random.randint(4, 10))
def track_event(category=None, action=None, label=None):
if not settings.analytics.getboolean('enabled'):
return
anonymousConfig = Config()
anonymousConfig.anonimize_ip_address = True
tracker = Tracker('UA-138214134-3', 'none', conf=anonymousConfig)
try:
visitor = pickle.loads(base64.b64decode(settings.analytics.visitor))
except:
visitor = Visitor()
unique_id = long(random.getrandbits(32))
visitor.unique_id = unique_id
session = Session()
event = Event(category=category, action=action, label=label, value=1)
path = u"/" + u"/".join([category, action, label])
page = Page(path.lower())
tracker.add_custom_variable(CustomVariable(index=1, name='BazarrVersion', value=os.environ["BAZARR_VERSION"], scope=1))
tracker.add_custom_variable(CustomVariable(index=2, name='PythonVersion', value=platform.python_version(), scope=1))
if settings.general.getboolean('use_sonarr'):
tracker.add_custom_variable(CustomVariable(index=3, name='SonarrVersion', value=sonarr_version, scope=1))
if settings.general.getboolean('use_radarr'):
tracker.add_custom_variable(CustomVariable(index=4, name='RadarrVersion', value=radarr_version, scope=1))
tracker.add_custom_variable(CustomVariable(index=5, name='OSVersion', value=platform.platform(), scope=1))
try:
tracker.track_event(event, session, visitor)
tracker.track_pageview(page, session, visitor)
except:
pass
else:
settings.analytics.visitor = base64.b64encode(pickle.dumps(visitor))
with open(os.path.join(args.config_dir, 'config', 'config.ini'), 'w+') as handle:
settings.write(handle)
class PygaMixin(object):
"""
Add function to retrive ga data.
"""
def get_utma(self, *args, **kwargs):
"""
Gets stored __utma cookie
"""
user_id = kwargs.get('user_id')
if not hasattr(self, '_utma') or ('force' in kwargs and 'user_id' in kwargs):
try:
ga = Pygawrapper.objects.get(user_id=user_id)
_utma = ga.utma
_ip = ga.ip
except Pygawrapper.DoesNotExist:
_utma = None
if not _utma:
raise ObjectDoesNotExist('__utma for user %s does not exist in database. PygaMiddleware must set it first!')
self._utma = StringCookieJar(_utma)._cookies
self._ip = _ip
elif not hasattr(self, '_utma') and ('force' in kwargs and 'user_id' not in kwargs) :
raise ObjectDoesNotExist('You are trying to re-initialize pygwarapper but have not set utm values or forgot to pass user_id!')
return self._utma
def get_utmb(self, *args, **kwargs):
"""
Gets stored __utmb cookie
"""
user_id = kwargs.get('user_id')
if not hasattr(self, '_utmb') or ('force' in kwargs and 'user_id' in kwargs):
try:
ga = Pygawrapper.objects.get(user_id=user_id)
_utmb = ga.utmb
except Pygawrapper.DoesNotExist:
_utmb = None
if not _utmb:
raise ObjectDoesNotExist('__utmb for user %s does not exist in database. PygaMiddleware must set it first!')
self._utmb = StringCookieJar(_utmb)._cookies
elif not hasattr(self, '_utmb') and ('force' in kwargs and 'user_id' not in kwargs) :
raise ObjectDoesNotExist('You are trying to re-initialize pygwarapper but have not set utm values or forgot to pass user_id!')
return self._utmb
def set_utma(self, utma):
self._utma = utma
def set_utmb(self, utmb):
self._utmb = utmb
def set_ip(self, ip):
self._ip = ip
def set_utm(self, utma, utmb, ip):
self.set_utma(utma)
self.set_utmb(utmb)
self.set_ip(ip)
self.get_ga_tracker(force=True)
def get_ga_visitor(self, *args, **kwargs):
"""
Gets a visitor and optionally feeds it with __utma data if user_id is provided
"""
if not hasattr(self, 'ga_visitor') or 'force' in kwargs:
if 'user_id' in kwargs or 'force' in kwargs:
self.get_utma(**kwargs)
try:
self._utma.split('.')
except:
self.ga_visitor = Visitor()
else:
self.ga_visitor = Visitor().extract_from_utma(self._utma)
if self._ip:
self.ga_visitor.ip_address = self._ip
return self.ga_visitor
def get_ga_session(self, *args, **kwargs):
"""
Gets a session and optionally feeds it with __utmb data if user_id is provided
"""
if not hasattr(self, 'ga_session') or 'force' in kwargs:
if 'user_id' in kwargs or 'force' in kwargs:
self.get_utmb(**kwargs)
try:
self._utmb.split('.')
except:
self.ga_session = Session()
else:
self.ga_session = Session().extract_from_utmb(self._utmb)
return self.ga_session
def get_ga_tracker(self, GOOGLE_ANALYTICS_CODE=GA_CODE, GOOGLE_ANALYTICS_SITE=GA_SITE, *args, **kwargs):
"""
Creates a tracker and fills it with session and visitor, optionally matched with given user if user_id is provided
Returns self for convenient use of other wrapped functions
Pass force=True in to re-initiate the tracker
"""
if not hasattr(self, 'ga_tracker') or 'force' in kwargs:
self.ga_tracker = Tracker(GOOGLE_ANALYTICS_CODE, GOOGLE_ANALYTICS_SITE)
self.get_ga_session(**kwargs)
self.get_ga_visitor(**kwargs)
return self
def track_pageview(self, path, **kwargs):
"""
@variable str page
@variable dict kwargs (optional) {'title', 'charset', 'referrer', 'load_time'}
Sends page hit to GA with given path as the page
"""
page = Page(path)
page.title = kwargs.get('title', None)
page.charset = kwargs.get('charset', None)
page.referrer = kwargs.get('referrer', None)
page.load_time = kwargs.get('load_time', None)
self.ga_tracker.track_pageview(page=page,session=self.ga_session,visitor=self.ga_visitor)
def track_transaction(self, transaction, items):
"""
@variable dict transaction {'order_id', 'order_id', 'tax', u'affiliation', 'shipping', u'city', u'state',
u'country'}
@variable list of dicts items [{'sku', u'name', 'variation', 'price', 'quantity' }, {...}]
Sends transaction to GA e-commerce
"""
trans = Transaction()
trans.order_id = transaction.get('order_id', None)
trans.total = transaction.get('total', None)
trans.tax = transaction.get('tax', None)
trans.affiliation = transaction.get('affiliation', None)
trans.shipping = transaction.get('shipping', None)
trans.city = transaction.get('city', None)
trans.state = transaction.get('state', None)
trans.country = transaction.get('country', None)
for item in items:
gitem = gaItem()
gitem.sku = item.get('sku', None)
gitem.name = item.get('name', None)
gitem.variation = item.get('variation', None)
gitem.price = item.get('price', None)
gitem.quantity = item.get('quantity', 1)
trans.add_item(gitem)
self.ga_tracker.track_transaction(transaction=trans,session=self.ga_session,visitor=self.ga_visitor)
def track_event(self, category=None, action=None, label=None, value=None, noninteraction=False):
"""
@variable str category
@variable str action
@variable str label
@variable str value
@variable bool noninteraction
Sends event to GA
"""
e = Event(category=category, action=action, label=label, value=value)
self.ga_tracker.track_event(event=e,session=self.ga_session,visitor=self.ga_visitor)
from pyga.requests import Tracker, Page, Session, Visitor, Event
tracker = Tracker('UA-78705248-1', 'http://127.0.0.1:8080')
visitor = Visitor()
visitor.ip_address = '194.54.176.12'
session = Session()
page = Page('/call')
event = Event('convertion', 'call') # category - action
tracker.track_pageview(page, session, visitor)
tracker.track_event(event, session, visitor)
def complete_process(request, backend, *args, **kwargs):
"""Authentication complete process"""
# pop redirect value before the session is trashed on login()
redirect_value = request.session.get(REDIRECT_FIELD_NAME, '') or \
request.REQUEST.get(REDIRECT_FIELD_NAME, '')
if GA_ID:
ga_tracker = Tracker(GA_ID, request.META.get('HTTP_HOST', ""))
utmz = request.COOKIES.get("__utmz")
if utmz:
try:
campaign = Campaign()
campaign.extract_from_utmz(utmz)
ga_tracker.campaign = campaign
except:
pass
ga_visitor = Visitor()
try:
ga_visitor.extract_from_utma(request.COOKIES.get("__utma",""))
except:
pass
ga_visitor.ip_address = request.META.get('REMOTE_ADDR')
ga_session = Session()
try:
ga_session.extract_from_utmb(request.COOKIES.get("__utmb"))
except:
pass
else:
ga_tracker = None
# Django 1.5 allow us to define custom User Model, so integrity errors
# can be raised.
try:
user = auth_complete(request, backend, *args, **kwargs)
except IntegrityError:
try:
if ga_tracker:
ga_tracker.track_event(Event("Logins",backend.AUTH_BACKEND.name+"CompleteError",
request.build_absolute_uri()),
ga_session, ga_visitor)
except:
pass
url = setting('SIGNUP_ERROR_URL', setting('LOGIN_ERROR_URL'))
return HttpResponseRedirect(url)
if isinstance(user, HttpResponse):
return user
if not user and request.user.is_authenticated():
return HttpResponseRedirect(redirect_value)
msg = None
if user:
if getattr(user, 'is_active', True):
# catch is_new flag before login() might reset the instance
is_new = getattr(user, 'is_new', False)
login(request, user)
# user.social_user is the used UserSocialAuth instance defined
# in authenticate process
social_user = user.social_user
if redirect_value:
request.session[REDIRECT_FIELD_NAME] = redirect_value or \
DEFAULT_REDIRECT
if setting('SOCIAL_AUTH_SESSION_EXPIRATION', True):
# Set session expiration date if present and not disabled by
# setting. Use last social-auth instance for current provider,
# users can associate several accounts with a same provider.
expiration = social_user.expiration_datetime()
if expiration:
try:
request.session.set_expiry(expiration)
except OverflowError:
# Handle django time zone overflow, set default expiry.
request.session.set_expiry(None)
# store last login backend name in session
key = setting('SOCIAL_AUTH_LAST_LOGIN',
'social_auth_last_login_backend')
request.session[key] = social_user.provider
# Remove possible redirect URL from session, if this is a new
# account, send him to the new-users-page if defined.
new_user_redirect = backend_setting(backend,
'SOCIAL_AUTH_NEW_USER_REDIRECT_URL')
if new_user_redirect and is_new:
url = new_user_redirect
else:
url = redirect_value or \
backend_setting(backend,
'SOCIAL_AUTH_LOGIN_REDIRECT_URL') or \
DEFAULT_REDIRECT
if ga_tracker:
ga_tracker.track_event(Event("Logins",backend.AUTH_BACKEND.name+"Complete",
request.build_absolute_uri()),
ga_session, ga_visitor)
else:
msg = setting('SOCIAL_AUTH_INACTIVE_USER_MESSAGE', None)
url = backend_setting(backend, 'SOCIAL_AUTH_INACTIVE_USER_URL',
LOGIN_ERROR_URL)
else:
msg = setting('LOGIN_ERROR_MESSAGE', None)
url = backend_setting(backend, 'LOGIN_ERROR_URL', LOGIN_ERROR_URL)
if ga_tracker:
ga_tracker.track_event(Event("Logins",backend.AUTH_BACKEND.name+"CompleteError",
request.build_absolute_uri()),
ga_session, ga_visitor)
if msg:
messages.error(request, msg)
if redirect_value and redirect_value != url:
redirect_value = quote(redirect_value)
if '?' in url:
url += '&%s=%s' % (REDIRECT_FIELD_NAME, redirect_value)
else:
url += '?%s=%s' % (REDIRECT_FIELD_NAME, redirect_value)
return HttpResponseRedirect(url)
def track_event(category=None, action=None, label=None):
if not settings.analytics.getboolean('enabled'):
return
anonymousConfig = Config()
anonymousConfig.anonimize_ip_address = True
tracker = Tracker('UA-138214134-3', 'none', conf=anonymousConfig)
try:
if os.path.isfile(os.path.normpath(os.path.join(args.config_dir, 'config', 'analytics.dat'))):
with open(os.path.normpath(os.path.join(args.config_dir, 'config', 'analytics.dat')), 'r') as handle:
visitor_text = handle.read()
visitor = pickle.loads(codecs.decode(visitor_text.encode(), "base64"))
if visitor.user_agent is None:
visitor.user_agent = os.environ.get("SZ_USER_AGENT")
if visitor.unique_id > int(0x7fffffff):
visitor.unique_id = random.randint(0, 0x7fffffff)
else:
visitor = Visitor()
visitor.unique_id = random.randint(0, 0x7fffffff)
except:
visitor = Visitor()
visitor.unique_id = random.randint(0, 0x7fffffff)
session = Session()
event = Event(category=category, action=action, label=label, value=1)
tracker.add_custom_variable(CustomVariable(index=1, name='BazarrVersion',
value=os.environ["BAZARR_VERSION"].lstrip('v'), scope=1))
tracker.add_custom_variable(CustomVariable(index=2, name='PythonVersion', value=platform.python_version(), scope=1))
if settings.general.getboolean('use_sonarr'):
tracker.add_custom_variable(CustomVariable(index=3, name='SonarrVersion', value=sonarr_version, scope=1))
else:
tracker.add_custom_variable(CustomVariable(index=3, name='SonarrVersion', value='unused', scope=1))
if settings.general.getboolean('use_radarr'):
tracker.add_custom_variable(CustomVariable(index=4, name='RadarrVersion', value=radarr_version, scope=1))
else:
tracker.add_custom_variable(CustomVariable(index=4, name='RadarrVersion', value='unused', scope=1))
tracker.add_custom_variable(CustomVariable(index=5, name='OSVersion', value=platform.platform(), scope=1))
try:
tracker.track_event(event, session, visitor)
except:
logging.debug("BAZARR unable to track event.")
pass
else:
with open(os.path.normpath(os.path.join(args.config_dir, 'config', 'analytics.dat')), 'w+') as handle:
handle.write(codecs.encode(pickle.dumps(visitor), "base64").decode())
import random
import threading
from urllib import unquote, quote, quote_plus
try:
from hashlib import md5
except:
from md5 import md5
GAUID='UA-31027962-2'
from pyga.requests import Tracker, Page, Session, Visitor, Event, Config
CONFIG = Config()
CONFIG.anonimize_ip_address = True
tracker = Tracker(GAUID, 'xbmc.ru', conf=CONFIG)
import pickle
def get_platform():
platforms = {
"Linux": "X11; Linux",
"Windows": "Windows NT %d.%d",
"OSX": "Macintosh; Intel Mac OS X",
"IOS": "iPad; CPU OS 6_1 like Mac OS X",
}
for platform, ua_platform_name in platforms.items():
if xbmc.getCondVisibility("System.Platform.%s" % platform):
if platform == "Windows":
import sys
version = sys.getwindowsversion()
ua_platform_name %= (version[0], version[1])
