One way to see - how many people downloaded your extension - is to look at statistic in Chrome webstore.
Another way is to add inside background.js the chrome.runtime.onInstalled.addListener and send information on server each time, when somebody installed an extension.
My problem is that the information, collected by both these ways - is not similar.
Number of downloads, presented in Chrome webstore is less, than number of installations, collected by second way (for unique ip-addresses).
Why? Can anybody explain it?
chrome store also takes into account the uninstalls, while your method only counts installs.
you can also detect uninstalls by setting the url to open on uninstall and tally it on your server. see https://developer.chrome.com/extensions/runtime#method-setUninstallURL
with that, the numbers will match closer. still not perfect as the store takes sometimes weeks to add the stats for a day.
The number of unique IP addresses is not a reliable indicator for users, because users may be using a dynamic address (instead of a static IP address that does not change), and multiple users may be sharing an IP address (behind a NAT or proxy).
And chrome.runtime.onInstalled is not just triggered upon a new installation of your extension, but also when the browser/extension is updated.
So, your way of counting unique users is flawed (and given the small number of users, it is likely that your method is overestimating the number of users).
The Chrome Web Store dashboard (for developers only) provides the number of daily installations (probably measured by counting the number of on-demand CRX downloads).
The Chrome Web Store publicly shows the number of weekly users (measured by counting the number of update checks per week).
This number is not the number of active weekly users, and probably over-estimates the number of actual users.
For example, I have an extension that used to have 1.7k users. Because the extension became obsolete, I published an update that sends a ping to my server and removes the extension itself (using chrome.management.uninstallSelf). Every week, I receive at most a few pings, yet the CWS claims that the extension has about 400 weekly users (these users probably disabled my extension; consequently the extension cannot remove itself but Chrome still checks for updates).
Accurately counting number of users
If you want to know the number of installations, look at the CWS dashboard. If you want to continue to use the onInstalled method, at the very least check whether details.reason === 'install'.
If you want to have the most reliable indicator of "user", generate a random identifier and store it in chrome.storage.sync. Include this ID in requests to the server (for sample code, see Getting unique ClientID from chrome extension?).
Recently, I introduced server-pings in one of my extensions, to measure the number of users per Chrome version at a given day/week. In this efforts, I prioritized the privacy of users over the accuracy of statistics (by storing the random ID in localStorage (which is not synchronized) and refreshing this ID at every major browser update).
If you want to learn more about the code behind it, see https://github.com/Rob--W/pdfjs-telemetry.
Related
a customer representative suggested that I try posting these questions here.
We spent some time monitoring issues with DocuSign loading slowly. While it was now slow every time, when it was slow it seemed to hang up on a particular point in the process.
Below is a screenshot of a trace we ran in the browser and note the element which took 52 seconds to load. When loading was slow, it seemed to hang on this particular element. Could you offer any reasons as to why it could sometimes take 52 seconds or more to load this part?
We also have some other questions:
There seems to be continuous font downloading (2 or 3 meg in size) throughout the process of loading the page. This occurs each time. Why is this and can it be avoided?
Why do we sometimes see Seattle as the connection site when most of the time is Chicago?
We noticed that DocuSign asks for permission to know our location. Does this location factor into where the document is downloaded from? Is the location also used in embedded signing processes?
Thank you for your assistance.
Unfortunately, without a bit more detail I am not entirely sure I can tell you why the page was loading so slow. Is this consistent? If so is it always the same document (perhaps template?) where you see this slowness?
As for your other three questions:
In doing my own test and decryption of the web traffic via fiddler I show the fonts being rendered for each individual tag and not the entire document. This is most likely due to each tag having it's own attributes that can be set (font included).
DocuSign data centers are in Seattle, Chicago and Dallas. All DocuSign traffic can come from any of these three data centers as the system synchronously exists in all three locations. More info can be found here.
DocuSign geo-location is just used to leverage the location capability of HTML5 enabled browsers but the signers IP address is recorded either way. It has no impact on which data center the traffic comes from. It is also included in the embedded signing process. It can be disabled on a per brand basis in the Signing Resource File setting the node DocuSign_DisableLocationAwareness to true.
Wondering if this is at all possible. I'm working on a Chrome extension where, as users browse a particular site, certain elements on the page are saved to chrome.storage.local (or chrome.storage.sync). Those elements are then called again later on a different page. However, it would be useful to allow all users to save this data to 1 global variable/source, and all users be able to read from that variable/source. Do Chrome extensions have any method of accomplishing this?
The data in question isn't anything sensitive, it's not authentication info or anything. The reason I'm hoping to do this and not just save static variables or JSON objects within a content script is that the website I'm building this for changes fairly frequently, and I would rather that data not be completely static.
Thank you!
Not possible natively but there are lots of ways to do it for free (given you have few users and load and assuming you dont surpass their free quotas or rate limits) like a google appengine backend or a public google spreadsheet as sync. For the spreadsheet case, you can store as rows or put everything on a single cell. For appengine, the datastore has free quotas for read/write and free store quota (with limits and rate limits of course).
I'm developing a Google Chrome Extension that needs to create many bookmarks and folders.
My problem is, that I don't understand, how Chrome counts the write requests that are limited by the value of chrome.bookmarks.MAX_SUSTAINED_WRITE_OPERATIONS_PER_MINUTE.
Last week I created about 1000 bookmarks in a loop to test that limit - the bookmarks were all created and after it I could delete them with the API, too.
Today I also tested an extension, that synced all my ~500 bookmarks from Pinboard - without any problem.
But now (after some write operations while developing) I receive an error on every single write operation that tells me, that the limit has exceeded. Even after ~30min of waiting and not touching the API.
So my question is: how does Google count that operations / when does it block my operations?
And why didn't it block i.e. the Pinboard-Extension?
Thank you in advance!
Chrome maintains an in-memory blacklist of extensions that have exceeded their quota. The OP is expecting this blacklist to be expunged after the stated period. This does not happen. The blacklist is never cleared down. However it is only in memory, so killing and restarting the browser will clean it, and the extension will function again.
You were probably banned. Understand that chrome.bookmarks and chrome.storage involve usage of server-side resources via syncing. When you create a large number of requests, it doesn't affect just your own machine; it affects the sync servers, too.
Because the limit was put in place to protect against abuse/bugs and help provide a reliable service for all users, it's unlikely anyone will give you a better answer than the official documentation. Abusers would use that information to their advantage. I know you're not trying to abuse the sync service, but others might, which is why the real limits aren't published anywhere.
i trying make an internet voting service but the problem is internet is just so easy to cheat by creating multiple accounts and vote same thing. capcha and email is not helping as take just 3 second to pass by human. IP can be changed by proxy. if we put some cookie on voter browser he just clean it next time.
i created this question to ask help for methods we can use with basic futures that all browsers have (javascript etc)to prevent our service being cheated easily.
the first idea i have myself is that possible my website access all cookies user have on his browser by just visiting my site ? because when they clean everything by CCleaner for new accounts then i can understand the browser is empty so the person is perhaps a cheater as most of real users when come to my site always have at least several cookie from different sites
There is no way to address the issue of uniquely identifying real-world assets (here: humans) without stepping out of your virtual system, by definition.
There are various ways to ensure a higher reliability of the mapping "one human to exactly one virtual identity", but none of them is fool-proof.
The most accessible way would be to do it via a smartphone app. A human usually only has one smartphone (and a phone number).
Another way is to send them snail mail to their real address, with a secret code, which you require them to enter in your virtual system.
or the social insurance number
or their fingerprints as log in credentials
The list could go on, but the point is, these things are bound to the physical world. If you combine more such elements, you get a higher accuracy (but never 100% certainty).
I have developed a windows application.I just want to set a trial period for 30days. After that the user should get the message about Trial period has been completed and make the buttons to be inactive state. Suggest me some links.
This is not something which can be done with a single thought. It depends on various factors related to your application. Is your application has access to registry or not? Is it installed with administrator privileges or not.
I can give you some idea on how do it with basic privileges.
Create an encrypted key which takes current system date and some other parameter which you can take as you wish and store this key in a file in the application folder or wherever you can.
Every time user starts the application get the key and decrypt it and check whether the date stored minus today is more than your trial period than based on that you need to do whatever action you can such as disabling buttons etc.
I'm sure there are so many other methods followed by others and everybody has their own criteria and constraints in this implementation.
Some questions you really need to ask yourself are:
How important is what you are trying to protect?
How much are you willing to pay (in time, money and effort) to
implement this behavior?
What are the chances people are going to try and bypass your
implementations?
Is the cost (in time, money and effort) going to be more than the
potential lose in income from people bypassing the trial period?
There is another question on SO with similar requirement, go through those answers as well.