User turnstile event #6980

asheemmamoowala · 2018-07-17T20:24:06Z

What is in this change?

Just like the mapbox-gl-native mobile SDKs, mapbox-gl-js will send a turnstile event, once per calendar day, when (and only when) the Mapbox access token is set and resources are loaded from a Mapbox API. No turnstile event will be sent for maps that use only third-party styles and tiles. This is the same behavior as the mapbox-gl-native mobile SDKs.

The turnstile event generates a random id that is persisted in the browser's localStorage (when available). No other personal identifiable information is sent as part of this event. The subdomain that processes the event is distinct from the tiles API servers and Mapbox does not connect events between the two. There is no way for us to connect style and tile requests to an individual user.

You can view the part of our privacy policy that covers random identifiers here

Why is this needed?

Today, the way that Mapbox determines distinct users of the gl-js sdk is imprecise. A turnstile event helps get more accurate information about things like:

How many users are active on an account monthly. Our licensing incorporates end user limits for commercial applications; this change will allow us to closely track these numbers and make them visible to customers.
What versions of gl-js are being used by end-users, and what browsers are being used. This will help us prioritize browser compatibility issues and support for cutting-edge technologies such as WebGL 2.

Additionally, as a company we want to use consistent metrics across all our platforms. This change brings the web platform in sync with our mobile platforms.

Can I opt out of this tracking?

If your use of mapbox-gl-js does not set the access token (using mapboxgl.accessToken) then this code is always disabled. When the access token is set, there is no option to disable the turnstile event.

Launch Checklist

briefly describe the changes in this PR
write tests for all new functionality
~~document any changes to public APIs~~
~~post benchmark scores~~
manually test the debug page

cc @jfirebaugh @anandthakker

jfirebaugh · 2018-07-17T20:58:42Z

src/util/ajax.js

+            callback(null, xhr.response);
+        } else {
+            if (xhr.status === 401 && requestParameters.url.match(/mapbox.com/)) {
+                callback(new AJAXError(`${xhr.statusText}: you may have provided an invalid Mapbox access token. See https://www.mapbox.com/api-documentation/#access-tokens`, xhr.status, requestParameters.url));


This case isn't applicable here.

jfirebaugh · 2018-07-17T21:03:19Z

src/util/mapbox.js

+    // mapbox tiles.
+    if (!config.ACCESS_TOKEN ||
+        !tileUrls ||
+        !tileUrls.some((url) => { return /mapbox.c(n)|(om)/i.test(url); })) {


Use parseUrl here. (This regex will match mapbox-com, and mapbox.com in a query string.)

parseUrl throws, and I'd like to avoid having a try..catch. Even with the authority parsed out of the url, it will need a check for mapbox.com and mapbox.cn.

jfirebaugh · 2018-07-17T21:05:00Z

src/util/mapbox.js

+    let pending = false;
+    //Retrieve cached data
+    if (localStorageAvailable) {
+        const data = window.localStorage.getItem(STORAGE_TOKEN);


Any use of window.localStorage should be wrapped in try/catch. I know you're preflighting with storageAvailable, but localStorage is wonky and can become unavailable mid-flight if a space quota is filled or the user changes permissions.

jfirebaugh · 2018-07-17T21:10:41Z

src/util/mapbox.js

@@ -119,3 +125,72 @@ function formatUrl(obj: UrlObject): string {
    const params = obj.params.length ? `?${obj.params.join('&')}` : '';
    return `${obj.protocol}://${obj.authority}${obj.path}${params}`;
 }
+
+const STORAGE_TOKEN = 'mapbox.userTurnstileData';
+const localStorageAvailable = storageAvailable('localStorage');


What's the failure mode if local storage isn't available?

There is no fallback for saving the last update time locally - it would send multiple requests. Are you thinking that there should be a local variable for lastUpdateTime so that in a given instantiation of Map, this still maintains the once per day frequency?

jfirebaugh · 2018-07-17T21:15:25Z

src/util/mapbox.js

+
+    postData(request, payload, (error) => {
+        if (!error && localStorageAvailable) {
+            window.localStorage.setItem(STORAGE_TOKEN, JSON.stringify({


It looks like there's a race condition if postTurnstileEvent is called twice in quick succession. Both calls could result in calling postData before either one receives a response and updates lastSuccess.

Oh nice catch! There isn't a great way to remedy this other than adding a queue. After a first call, if subsequent calls are ignored until the pending request is complete, a failed request (server down for example) would lose events.

jfirebaugh · 2018-07-17T21:16:43Z

src/util/mapbox.js

@@ -119,3 +125,72 @@ function formatUrl(obj: UrlObject): string {
    const params = obj.params.length ? `?${obj.params.join('&')}` : '';
    return `${obj.protocol}://${obj.authority}${obj.path}${params}`;
 }
+
+const STORAGE_TOKEN = 'mapbox.userTurnstileData';


Doesn't the storage key need to include the access token, for e.g. the embed page?

jfirebaugh · 2018-07-17T21:19:00Z

test/ajax_stubs.js

@@ -64,6 +64,18 @@ export const getArrayBuffer = function({ url }, callback) {
    });
 };

+export const postData = function({ url }, payload, callback) {
+    if (cache[url]) return cached(cache[url], callback);


Probably shouldn't cache POSTs, even in tests.

jfirebaugh · 2018-07-17T21:24:12Z

src/util/mapbox.js

+        const lastUpdate = new Date(lastUpdateTime);
+        const now = new Date();
+        const daysElapsed = (+now - Number(lastUpdateTime)) / (24 * 60 * 60 * 1000);
+        pending = pending || daysElapsed >= 1 || daysElapsed < 0 || lastUpdate.getDate() !== now.getDate();


Is there any situation where lastUpdate.getDate() !== now.getDate() would be continuously true for some extended period of time (timezone change, leap day, DST cutover, ...)?

Sure thats possible, but daysElapsed is based on UTC time and would be >=1 or <0 anyways, so it would still send an event.

jfirebaugh · 2018-07-17T21:28:07Z

src/util/mapbox.js

+        userId: anonId
+    }]);
+
+    postData(request, payload, (error) => {


We're not returning the result of postData here, so the request can't be cancelled by map.remove() (see #6826). That's probably okay, since the response callback doesn't really communicate with the outside world. But if it's straightforward to implement cancellation, let's do it anyway.

mb12 · 2018-07-18T02:13:31Z

@asheemmamoowala Can you please kindly clarify the following?

1.) What is the difference between turnstile event and telemetry data that is collected on the native side (if any)? GL Native collects information pertaining to touches, gestures, geo location when tracking is enabled etc. Does the GL JS also track these and post this with each turnstile event?

What is the estimated bandwidth usage that can be attributed to information posted per turnstile event? Recently the following issue was filed on the native side regarding data usage attributed to telemetry.
High Telemetry Data Usage mapbox-gl-native#11979

asheemmamoowala · 2018-07-18T19:35:35Z

What is the difference between turnstile event and telemetry data that is collected on the native side (if any)? GL Native collects information pertaining to touches, gestures, geo location when tracking is enabled etc. Does the GL JS also track these and post this with each turnstile event?

@mb12 the turnstile event is a single event when a Map first requests a tile from a Mapbox API server, limited to one per calendar day. GL-JS does not track user interactions (touches and gestures) or geo location. The telemetry data collected by Mobile SDKs includes many more events including intermittent location updates.

What is the estimated bandwidth usage that can be attributed to information posted per turnstile event?

Each turnstile event includes a POST with 6-7 parameters that combine to <200 bytes in size.

anandthakker · 2018-07-20T13:07:57Z

src/util/ajax.js

@@ -122,6 +123,24 @@ export const getArrayBuffer = function(requestParameters: RequestParameters, cal
    return { cancel: () => xhr.abort() };
 };

+export const postData = function(requestParameters: RequestParameters, payload: string, callback: Callback<mixed>): Cancelable {
+    requestParameters.method = 'POST';


nit: copy/extend requestParameters instead of mutating it

anandthakker · 2018-07-20T13:30:56Z

src/util/mapbox.js

@@ -119,3 +126,108 @@ function formatUrl(obj: UrlObject): string {
    const params = obj.params.length ? `?${obj.params.join('&')}` : '';
    return `${obj.protocol}://${obj.authority}${obj.path}${params}`;
 }
+
+class TurnstileEvent {
+    STORAGE_TOKEN: string;


Is there any reason for this to be an instance member rather than a static member or even just a local constant?

anandthakker · 2018-07-20T13:49:17Z

src/util/mapbox.js

+                }));
+                this.pendingRequest = null;
+                this.pending = false;
+                this.processRequests();


clearing the pending/pendingRequest state and processing the rest of the queue should happen unconditionally (i.e. even if there's an error).

Definitely a bug that the pending.. variables aren't cleared. For processRequests I think it should stop attempting to send requests if there is an error, until the next event is queued - in case of network connection loss, or a server outage.

Ah, yeah that seems reasonable

anandthakker · 2018-07-20T13:55:08Z

test/unit/util/mapbox.test.js

+            t.equal(reqBody.event, 'appUserTurnstile');
+            t.equal(reqBody.sdkVersion, version);
+            t.ok(reqBody.userId);
+


Add req.respond(200) so that the TurnstileEvent's pending state has an opportunity to be cleared

anandthakker · 2018-07-20T13:59:52Z

test/unit/util/mapbox.test.js

+            t.false(req);
+
+            t.end();
+        });


These tests should stub browser.now() and include a test that we do post the turnstile event one day later.

They should also test the expected behavior:

With and without localStorage available (currently, I think they're testing without it)

For a page that remains open > 1 day

For a page that is closed and reopened a day later (i.e., the load-from-localStorage path)

For a page that remains open > 1 day

This is currently treated as a single event until the page requests a new mapbox vector/raster source.

Should also test the queuing mechanism.

Still need tests for the load-from-localStorage path (which will require stubbing localStorage)

anandthakker · 2018-07-20T14:01:10Z

src/util/mapbox.js

+        const nextUpdate = this.queue.shift();
+
+        // Record turnstile event once per calendar day.
+        if (this.eventData.lastSuccess) {


What's the expected behavior if localStorage is not available? As of now, it looks like we'd only send a turnstile event once per page in that case, since lastSuccess would never be set.

eventData caches the id and success values within a single session. But I see the problem, this value needs to be updated irrespective of localStorageAvailable when a request succeeds.

If localStorage is not available, there may be more than one event sent per calendar day, but the events server de-duplicates those.

anandthakker · 2018-07-20T14:06:47Z

src/util/mapbox.js

+            const lastUpdate = new Date(this.eventData.lastSuccess);
+            const nextDate = new Date(nextUpdate);
+            const daysElapsed = (nextUpdate - this.eventData.lastSuccess) / (24 * 60 * 60 * 1000);
+            dueForEvent = dueForEvent || daysElapsed >= 1 || daysElapsed < 0 || lastUpdate.getDate() !== nextDate.getDate();


What's the reason for the lastUpdate.getDate() !== nextDate.getDate() condition? When would these two dates be equal?

daysElapsed is not perfectly named. It calculates how many 24-hr periods have elapsed since the last update. Notifications should be sent once per calendar day, so the date check allows testing for situations where a user loads the map at 11pm and again at 1am.

Date#getDate() returns just the day of the month, so it would be equal on 6/20 and 7/20. The combined check returns true if the clock has gone backwards (fly east), or forward ( by 24+ hrs or by a calendar date).

Date#getDate() returns just the day of the month, so it would be equal on 6/20 and 7/20.

Ahhh 🤦‍♂️

jfirebaugh · 2018-07-23T18:24:57Z

src/util/util.js

+ * @param str string to validate.
+ */
+export function validateUuid(str: ?string): boolean {
+    return str ? /^[0-9a-f]{8}-[0-9a-f]{4}-[4][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(str) : false;


return str && /.../i.test(str);

Flow complaints that

- null or undefined [1] is incompatible with boolean [2]. - string [3] is incompatible with boolean [2].

jfirebaugh · 2018-07-23T18:25:09Z

src/util/util.js

+export function uuid(): string {
+    function b(a) {
+        return a ? (a ^ Math.random() * 16 >> a / 4).toString(16) :
+        //$FlowFixMe


What's this for?

Flow doesn't like the implied array literal conversion in : ([1e7] + -[1e3] + -4e3 + -8e3 + -1e11).

array literal [1] is not a number.

^ let's include a comment justifying the $FlowFixMe

jfirebaugh · 2018-07-23T18:30:46Z

src/util/mapbox.js

@@ -119,3 +126,113 @@ function formatUrl(obj: UrlObject): string {
    const params = obj.params.length ? `?${obj.params.join('&')}` : '';
    return `${obj.protocol}://${obj.authority}${obj.path}${params}`;
 }
+
+class TurnstileEvent {
+    static STORAGE_TOKEN: string;


Make these regular variables at file scope.

jfirebaugh · 2018-07-23T18:33:13Z

src/util/mapbox.js

+class TurnstileEvent {
+    static STORAGE_TOKEN: string;
+    static localStorageAvailable: boolean;
+    eventData: Object;


eventData: { anonId: ?string, lastSuccess: ?number }

jfirebaugh · 2018-07-23T18:33:39Z

src/util/mapbox.js

+                try {
+                    const data = window.localStorage.getItem(TurnstileEvent.STORAGE_TOKEN);
+                    if (data) {
+                        const json = JSON.parse(data);


this.eventData = JSON.parse(data);

jfirebaugh · 2018-07-23T18:36:11Z

src/util/mapbox.js

+                this.eventData.lastSuccess = nextUpdate;
+                if (TurnstileEvent.localStorageAvailable) {
+                    try {
+                        window.localStorage.setItem(TurnstileEvent.STORAGE_TOKEN, JSON.stringify({


JSON.stringify(this.eventData)

jfirebaugh · 2018-07-23T19:04:30Z

src/util/mapbox.js

+            event: 'appUserTurnstile',
+            created: (new Date(nextUpdate)).toISOString(),
+            sdkIdentifier: 'mapbox-gl-js',
+            sdkVersion: `${version}`,


No need for string template.

jfirebaugh · 2018-07-23T19:05:48Z

test/unit/util/mapbox.test.js

+            t.false(req);
+
+            t.end();
+        });


Should also test the queuing mechanism.

…e servers

…dden' error on some machines

…t posted in quick succession

…uests on XHR error.

…age.

…from same source url with different tokens.

anandthakker · 2018-07-27T14:40:41Z

src/util/mapbox.js

+            this.eventData.anonId = this.eventData.lastSuccess = null;
+        }
+        if (!this.eventData.anonId || !this.eventData.lastSuccess &&
+            isLocalStorageAvailable) {


The || should be in parentheses (because && supercedes ||)

anandthakker · 2018-07-27T14:58:33Z

src/util/util.js

+export function uuid(): string {
+    function b(a) {
+        return a ? (a ^ Math.random() * 16 >> a / 4).toString(16) :
+        //$FlowFixMe


^ let's include a comment justifying the $FlowFixMe

anandthakker · 2018-07-27T15:10:09Z

test/unit/util/mapbox.test.js

+            const stub = t.stub(browser, 'now');
+            stub.onCall(0).returns(today);
+            stub.onCall(1).returns(laterToday);
+            stub.onCall(2).returns(tomorrow);


This approach to stubbing could be fragile, because it assumes that browser.now is only called once per postTurnstileEvent call. Alternative:

let now = Date.now(); t.stub(browser, 'now').callsFake(() => now); mapbox.postTurnstileEvent(['a.tiles.mapbox.com']); const reqToday = window.server.requests[0]; reqToday.respond(200); let reqBody = JSON.parse(reqToday.requestBody)[0]; t.ok(reqBody.created, new Date(now).toISOString()); now += 1; // later today mapbox.postTurnstileEvent(['b.tiles.mapbox.com']); t.ok(window.server.requests.length === 1); now += (25 * 60 * 60 * 1000); // tomorrow mapbox.postTurnstileEvent(['c.tiles.mapbox.com']); const reqTomorrow = window.server.requests[1]; reqTomorrow.respond(200); reqBody = JSON.parse(reqTomorrow.requestBody)[0]; t.ok(reqBody.created, new Date(now).toISOString());

The point of this test is to test the queuing mechanism(as suggested by @jfirebaugh previously(comment). Events are queued correctly triggered consecutively and/or responses are returned with a higher latency. The alternative you suggest is a serial approach that is being tested already.

Ah, I see. We should be able to use the more explicit approach to manipulating mock-time though, right?

anandthakker · 2018-07-27T15:11:47Z

test/unit/util/mapbox.test.js

+            t.false(req);
+
+            t.end();
+        });


Still need tests for the load-from-localStorage path (which will require stubbing localStorage)

anandthakker · 2018-07-27T20:28:34Z

test/unit/util/mapbox.test.js

+                window.localStorage.setItem(`mapbox.turnstileEventData:${config.ACCESS_TOKEN}`, JSON.stringify({
+                    anonId: uuid(),
+                    lastSuccess: now + ms25Hours // 24-hours later
+                }));


I think it would be better to test this by calling postTurnstileEvent twice, with the (stubbed) time being set back between calls, rather than setting localStorage directly

Are you implying that the test should cover the case of the queue receiving events in an out-of-order time sequence? In a single threaded environment, that situation seems highly unlikely. Even if it does happen, it should be counted as a single session IMHO.

Testing with LocalStorage allows verifying that clocks going back in time between sessions are accounted for, where it should be posted as a separate session correctly.

Oh -- no, I just meant that if possible, we should do this test using calls to postTurnstileEvent (the api being tested) rather than by directly manipulating localStorage (which requires baking more implementation details, like the storage key, into the test)

we should do this test using calls to postTurnstileEvent

I believe that within a single session, the clock going backwards should not report a new event - so this cannot be tested with calls to the method directly. To simulate calls across sessions, the best way is to change the access token and clear out the cached eventData

this cannot be tested with calls to the method directly

Why not, with something like:

let now = Date.now(); t.stub(browser, 'now').callsFake(() => now); mapbox.postTurnstileEvent(); // simulate system clock being set backwards now = now - 1000 * 60 * 60 * 24; mapbox.postTurnstileEvent();

This is a more direct simulation of the situation we're intending to test, and allows the test to avoid a dependency on implementation details.

That makes sense to add as a negative test, when clock moves bacward, new event is not set.

anandthakker · 2018-07-27T20:30:43Z

test/unit/util/mapbox.test.js

+                t.end();
+            });
+
+            t.test('does not POST appuserTurnstile event second time within same calendar day', (t) => {


Rather than having some tests rely on state from previous tests, I'd be in favor of making each test self-contained.
This could be done by moving the logic from mapbox.postTurnstileEvent into a method on TurnstileEvent, exporting the TurnstileEvent class, and having each test construct a new instance to test against.

I understand that it will make the tests self contained, but I think it is better to have a singleton TurnstileEvent for each instance of the map so that there can be a local cache of the eventData. Exposing the entire class without postTurnstileEvent being static would require the callers (Map in this case) to manage an instance of the event which seems unnecessary

Exposing the class doesn't preclude having a singleton at the module level:

export class TurnstileEvent { ... postTurnstileEvent(...) { /* actual logic */ } } const _turnstileEvent = new TurnstileEvent(); export function postTurnstileEvent() { return _turnstileEvent.postTurnstileEvent(...); }

Exported the class and updated the test names.

anandthakker

Looks good to me! (One minor issue with test assertions, noted below)

anandthakker · 2018-07-31T14:43:08Z

test/unit/util/mapbox.test.js

+                t.equal(reqBody.event, 'appUserTurnstile');
+                t.equal(reqBody.sdkVersion, version);
+                t.ok(reqBody.userId);
+                t.ok(reqBody.created, new Date(tomorrow).toISOString());


This should be t.equal. (t.ok only checks that the first argument is truthy). Also, should reqBody be JSON.parse(req.requestBody)[1] rather than [0]?

A few other t.ok(x, y)s should be t.equals as well

Good 👀 @anandthakker !

should reqBody be JSON.parse(req.requestBody)[1] rather than [0]?

Actually req should be window.server.requests[1]. Found and fixed after the t.equal change.

jingsam · 2018-08-01T04:31:02Z

There always should have an opt-out option, no matter access-token is set or not. Privacy does matter and you have the responsibility to tell users the purpose of data collection.

lilykaiser · 2018-08-01T20:48:45Z

Thanks for your comment @jingsam . We take the responsibility of protecting users' privacy seriously. That's why there is no way for us to connect style and tile requests to an individual end user, and no personally identifiable information is collected in this event other than a random identifier.

you have the responsibility to tell users the purpose of data collection.

As @asheemmamoowala mentioned in the original comment, we will use this data to track how many people are using different versions of gl-js to determine the severity of bugs and performance issues. It will also improve our tracking of how many users a commercial application has. Lastly, it brings our internal calculation of active users on gl-js in line with how we calculate mobile users.

We want to facilitate clear communication between us, developers who use our products, and end users. I hope the above points clarify why Mapbox wants to collect an end user number to our developer community.

We unfortunately can't offer opting out while using Mapbox map tile APIs, because this (anonymous) usage information is important for us to sustainably maintain this service. If opting out is a hard requirement for you, note that Mapbox GL JS may be used with other tile services.

scottgerring · 2018-11-07T04:39:31Z

Will these localStorage items be cleaned out at some point? We're seeing more and more items stashed in there over time but apparently no removal.

asheemmamoowala · 2018-11-08T00:54:28Z

@scottgerring Removal is not in our current implementation or upcoming plans. Please open an issue with reproducible steps if you think that there are an unreasonable number of items being added to the local storage.

asheemmamoowala requested review from jfirebaugh and anandthakker July 17, 2018 20:24

jfirebaugh reviewed Jul 17, 2018

View reviewed changes

asheemmamoowala force-pushed the user-turnstile-event branch 2 times, most recently from f5f5b64 to 35dba09 Compare July 18, 2018 23:10

anandthakker suggested changes Jul 20, 2018

View reviewed changes

jfirebaugh reviewed Jul 23, 2018

View reviewed changes

Asheem Mamoowala added 10 commits July 25, 2018 18:41

Ajax POST helper

d377f69

Send a user Turnstile event anytime a TilJSON is used with mapbox til…

ddb9898

…e servers

Unit tests for Mapbox#postTurnstileEvent

e0cfc97

Include mapbox.cn endpoints

82c0e58

Update jsdom to 11.11.0 to get rid of 'Error: Cross origin null forbi…

d96e5fd

…dden' error on some machines

Address commments from review

790694e

Use a queue and in-memory state to ensure that multiple events are no…

ccde5c7

…t posted in quick succession

Error-ed requests should clear pending variables. Stop processing req…

9c8fd96

…uests on XHR error.

Consider access token change as a new user to support iFrame/embed us…

2c25dd8

…age.

Segment locally stored data by access token to allow multiple embeds …

ab94794

…from same source url with different tokens.

asheemmamoowala force-pushed the user-turnstile-event branch from 82e41e3 to ab94794 Compare July 26, 2018 01:41

anandthakker reviewed Jul 27, 2018

View reviewed changes

Add unit tests with mock LocalStorage

b0e18e4

anandthakker reviewed Jul 27, 2018

View reviewed changes

Expose TurnstileEvent class and fixup tests to be independent of order.

749ec7a

anandthakker approved these changes Jul 31, 2018

View reviewed changes

Fix tests

f92adfc

asheemmamoowala merged commit b37dede into master Aug 6, 2018

asheemmamoowala deleted the user-turnstile-event branch August 6, 2018 19:45

andrewharvey mentioned this pull request Nov 20, 2018

turnstile event localStorage cleaning #7602

Closed

asheemmamoowala mentioned this pull request Dec 6, 2018

[docs]Add mapbox events domain to CSP directives #7680

Merged

dhango mentioned this pull request Jan 29, 2019

Test submit #7839

Closed

User turnstile event #6980

User turnstile event #6980

Conversation

asheemmamoowala commented Jul 17, 2018 • edited Loading

What is in this change?

Why is this needed?

Can I opt out of this tracking?

Launch Checklist

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mb12 commented Jul 18, 2018

asheemmamoowala commented Jul 18, 2018

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

asheemmamoowala Jul 20, 2018 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

asheemmamoowala Jul 23, 2018 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

anandthakker Jul 30, 2018 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

anandthakker left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jingsam commented Aug 1, 2018 • edited Loading

lilykaiser commented Aug 1, 2018

scottgerring commented Nov 7, 2018

asheemmamoowala commented Nov 8, 2018

asheemmamoowala commented Jul 17, 2018 •

edited

Loading

asheemmamoowala Jul 20, 2018 •

edited

Loading

asheemmamoowala Jul 23, 2018 •

edited

Loading

anandthakker Jul 30, 2018 •

edited

Loading

jingsam commented Aug 1, 2018 •

edited

Loading