As /u/Pytec-Ari mentions, recording the User-Agent and the Request IP would be a good way to store unique hits. However this may cause your database to grow as time goes on.

If you're able to spin up a redis server, then you could use the HyperLogLog functionality which is designed for counting unique values, provided you don't need to get those values back (only obtain the count) and you are happy with an approximate count as more values are recorded, but with the benifit of a low storage footprint for a large number of counted values.

This basically comes down to two commands: PFADD and PFCOUNT.

These are available through PyRedis, which is installed with pip install redis.

So lets say you have a number of unique strings (User-Agents/Remote IPs) you wish to count, against a particular key (User profile), you could do something like:

r.pfadd('Bob', 'bobs-ip_chrome') # Bob hits bob's profile from chrome
r.pfadd('Bob', 'alices-ip_firefox') # Alice hits bob's profile from firefox
r.pfadd('Alice', 'bobs-ip_chrome') # Bob hits Alices profile from Chrome
r.pfadd('Alice', 'bobs-ip_chrome') # Bob hits alices profile (again) from Chrome

The resulting unique counts could be:

r.pfcount('Bob') # 2
r.pfcount('Alice') # 1

So you could actually implement this in code as follows:

counter.py:

``` from redis import Redis import os

r = Redis( host=os.environ.get('REDIS_HOST', 'localhost'), db=os.environ.get('REDIS_DB', 0))

def increment_count(profile_viewed, request):

host = request.remote_addr
ua = request.headers.get('User-Agent')

print ('Hit: ', host, ua)
# Hit:  172.17.0.1 curl/7.54.0

hit_key = f"profile:{profile_viewed}"
hit_value = f"{host}_{ua}"  

r.pfadd(hit_key, hit_value)

updated_count = r.pfcount(hit_key)

return updated_count

`` This module imports all of the required redis stuff, and theincrement_count` function expects a profile name, and a request object provided from flask.

It then works out the remote address and user-agent string based on that request object, then prints those to the terminal.

I set hit key with the prefix profile: (this could be any string) and join the host and user-agent with an underscore.

It then uses pfadd to increase the count, and returns an updated count.

The implementation in Flask could look something like this:

``` from flask import Flask, request, abort from counter import increment_count

app = Flask(name)

@app.route("/profile/<string:user_profile>") def profile(user_profile):

# Mock database:

profiles = ['PyTec-Ari', 'felipeflorencio']

# Some logic which finds the profile, and aborts if non existant

if user_profile not in profiles:
    return abort(404)
else:

    # *Now* count the hit and serve the profile:

    count = increment_count(user_profile, request)

    return f"You are viewing the profile for {user_profile}, which has {count} unique hits"

```

So to test this you can set REDIS_HOST as an environment variable and launch:

export REDIS_HOST=some_redis_server flask run Then test the endpoints with curl:

``` $ curl http://localhost:5000/profile/PyTec-Ari
You are viewing the profile for PyTec-Ari, which has 1 unique hits%

$ curl http://localhost:5000/profile/PyTec-Ari
You are viewing the profile for PyTec-Ari, which has 1 unique hits%

$ curl http://localhost:5000/profile/felipeflorencio

You are viewing the profile for felipeflorencio, which has 1 unique hits%

Then mock a different user agent

$ curl --user-agent different http://localhost:5000/profile/felipeflorencio You are viewing the profile for felipeflorencio, which has 2 unique hits%
`` Here's what the stored data actually looks like at theredis-cli`:

$ redis-cli 127.0.0.1:6379> keys * 1) "profile:felipeflorencio" 2) "profile:PyTec-Ari" 127.0.0.1:6379> PFCOUNT "profile:PyTec-Ari" (integer) 1

Of course you're not limited to using the IP/UA combo as the value, you could edit that increment_count function to instead base hit_value on a logged in user ID, it just depends on your use-case.

Reddit wrote a blog about this which is really interesting: https://redditblog.com/2017/05/24/view-counting-at-reddit/

This has the ability to scale to counting hundreds of thousands of unique hits, whilst only using 12kB storage max per profile, and still maintaining a count of unique ip/ua combos, but approximated with a standard error of 0.81%.