Now I’m not proposing a cure for this cancer. I don’t have one.

But I have always been a big fan of knowing how productive I am in a work day vs not. How many times do I switch contexts? How many websites do I visit in the course of an hour?

The earliest instance of a solution I can remember is when I found ManicTime in 2017. I immediately installed it on my laptop. I Loved it. It gave me all the information I needed about what I was doing during work, where my time was going, how long I was away and more. It looked like this -

Then I heard about Rize last year . It looked much better than ManicTime. Understandable since it was actually built for a consumer rather than for a service based company. But it cost way too much for a personal tracking software.

In the pursuit of finding a better Manictime and a cheaper Rize, I landed last year on Activity Watch. It came close to the best activity monitor I had ever used. It was opensource, configurable and I could add my own watchers.

I think even now it might be something I could configure for my Mac.

But the lure of vibecoding something for myself was too strong. Why, even Bilbo struggled with the dilemma -

That’s how I ended up creating the configurable, highly imaginatively named - “Where Did My Day Go”. The caveat is that this is built only for the Mac as of this writing. I plan to extend it to Windows and Linux as well.

It runs completely locally and tracks all my activities - which applications were used, which websites were accessed, how long I was away from my desk, how long I was active on certain applications I care about (Chrome, VS Code, Terminal etc. )

Now, I have never built anything for the Mac OS before. Even now, this is a Webapp. But the tricky parts were understanding how the monitoring and collection of metrics For the Mac OS was possible. Something that Claude taught me quite a bit about.

The Build

Note - Claude Code stores conversation history locally as JSONL files under ~/.claude/projects — I used this to retrieve my actual prompts.

Here was my initial prompt -

The next set of exchanges were about the choice of tech stack and the tracking mechanism. It asked me to pick from a set of stacks that it seemed to find apt for the task and on the basis of my preferences from other applications “vibe-built” -

While it helped me sort out 95% of the job, it still needed a few nudges. I captured the parts where I had to probe it - parts where it seemed extremely confident.

The Debugging

Bug 1: Chrome not showing up

It took four rounds before Claude found the actual issue : a stale run-loop in the long-running process. Then came the time inconsistencies.

Bug 2: An hour with more than 60 minutes

My callout of “max 60 mins” seems to have caught a genuine timezone bug Claude had initially explained away as legitimate.

Bug 3: Applications not getting tracked as expected.

Bug 4: Missing minutes

Claude was confident most of the time. But the bugs came from pressing it anyway. Goes to show that HITL is still relevant and will be for some time. But after all the battling, it finally it came up with a decent UI and correct metrics.

⚡Mid-article Moral - Never blindly trust an LLM agent. Question it.

The Stack

Two long-running processes, one SQLite file.

Collector (collector.py) : runs forever, samples every 5 seconds:

• Python 3.12 with pyobjc for the macOS bindings (Cocoa + Quartz frameworks)

• lsappinfo front (subprocess to the macOS LaunchServices CLI) : the focused app

• AppleScript via osascript : the active Chrome tab URL

• Quartz.CGEventSourceSecondsSinceLastEventType : idle time (seconds since last keyboard/mouse event)

• launchd : auto-start at login via a .plist user agent in ~/Library/LaunchAgents/

Storage (db.py):

• SQLite : single file, WAL mode + synchronous=NORMAL so the collector and the dashboard can hit it concurrently

• Schema: intervals, not samples. One row per consecutive run of identical (category, app, bundle, url, is_idle). The collector extends end_ts while the key matches, opens a new row when it changes. Months of data fits in ~40K rows.

Dashboard (server.py, frontend):

• Flask : three JSON endpoints and one HTML template, bound to 127.0.0.1 only

• Plain HTML / CSS / vanilla JS : no build step, no framework, no node_modules

• Chart.js 4 from a CDN : the only outbound network request the app makes; vendor it if you care

• CSS custom properties as design tokens : color variables like --c-claude_desktop live in styles.css and are read from JS via getComputedStyle, so chart colors and KPI border colors stay in sync from one source of truth

Project tooling:

• uv + pyproject.toml + .python-version : no pip, no manual venv.

• uv sync is the entire bootstrap;

• uv run python collector.py is how you run it.

The collector is the fun part . It is a single Python process supervised by launchd. Every 5 seconds it asks macOS four questions: and writes the answer to SQLite. To get the “focused app” right means using lsappinfo (LaunchServices) rather than AppKit or window-stacking order.

I tried to understand from Claude why lsappinfo front is better than AppKit or window-stacking order.

I also found an excellent follow-up read for lsappinfo.

So Where Did my day go?

Let’s take today as a usecase.

At the time of this screenshot, I seem to have spent ~52 minutes using VSCode and 45 minutes on Chrome. I was away from my desk for 9 hours and 59 minutes.

This is understandable since I’m tracking a 12 AM to 11.59 PM day and a large chunk of that time was spent sleeping. This is a great side benefit I’ve found to understand when I’m turning off for the day and an approximate time of when I’m back at my desk. For today, that seems to be from 12.45 AM to 8 AM. Not too bad I’d say!

How can you set this up?

Just follow the Quick Start section from the Readme file. There’s a simple bootstrap file you can use at install_launchd.sh. If you have doubts, DM me or raise an issue on the Github repo.

Future work (for me)

• I want to try and get more insights out of this. For example, can I sync my phone activity to this dashboard on a LAN? That way I can get proper , bifurcated sleep tracking as well since as a troubling consequence of the times, the phone is the last and first device I use before sleeping and after I rise.

• I also want to try and see if I can capture the time for which the mac was shut down explicitly.

• Thirdly I want to be able to add applications to be tracked a little more easy to configure. Right now, adding a new app to the dashboard is a spectrum. “Just track the time” needs zero config; every focused app gets logged regardless. “Give it its own category in the API” is one line in collector.py. “Give it a colored donut slice and a legend label” is a few edits across three files. “Give it a top-level KPI card” is two more. The data and the visuals aren’t yet driven by a single config today.

  ---

Thanks for reading this edition of Everything Python! Subscribe for free to receive new posts and support my work.

Also check out my Youtube channel and Subscribe. I hope to create more videos on all things Engineering - From coding in Python to Databases and GenAI !

Subscribe now

This means that there are a lot of dependent services that need to be run first that support the overall execution of the platform.

For e.g. -

Our platform's stack requires SQL Server, Solr, Redis, Postgres, RabbitMQ, MongoDB as core services to be running first.

Once these are all running and available, a service called WebAPI can be run that makes use of some of the above to run as well.

Following this, there are a few more microservices that need to run, but that need not be part of this article since the underlying concept will already come through with the above being demonstrated.

It all started when in practice on a day-to-day basis, whenever I spun up these services, every now and then, at least ONE of them would go down and at best, the error trace was clear enough from the dependent services as to what the issue was.

But at worst, it's a rabbit hole of errors to wade through before I would land on the root cause and if one of the service's unavailability was the cause, I would feel really sad about having lost all that time.

So having gone through this time and time again, I thought I could do something about this.

ITERATION 1 - The first result of this thought was simply - a checklist.

While it got the bare minimum accomplished, in that, I now had a ready reckoner of all the services that needed to be up each time, I had no way of tracking when something went Down during operations. Additionally, if any of the services were not started , either at startup or by me, the service would simply be neglected till such time as an error would alert me.

Rejected coz : Tick-boxes fixed my initial forgetfulness but still left me blind to mid-session crashes.

This was not working out.

Over time, I tried/considered a few more things -

a) writing a script to start them all at once at startup - this failed miserably more often than not since there were some interfering services running because of other ongoing experiments.

b) Creating batch scripts since aliases were missing in Windows and this is predominantly a Windows based platform

c) Docker-izing All the services. But the amount of RAM that was consumed when I ran all the services (except SQL Server and company-specific-services) was a bit more than I liked - speaks to my lack of knowledge in optimizing Docker, I'm sure.

d) I was also suggested a Prometheus dashboard that I summarily rejected because of the unnecessary level of complexity I was inviting for myself for a personal setup. (Although, I Will set something up with Prometheus eventually - just for masochism's sake.)

So after months of this sort of juggling, a few weeks ago, I thought -

Actually let's back up - Iteration 2.

I did not think of Textual right from the start. Because initially all I knew was, I wanted a dashboard that would monitor all the services I have running and I could look at for when something went down.

So the second iteration’s end result was something like this -

Rejected coz : Curling ports gave me machine-readable streaming truth, but looking at raw JSONs is still annoying.

Iteration 3 -

The improvement on the above was a CLI based table with ASCII ✔ and ✖ .
Like so -

Rejected coz : A CLI table with ✔/✖ cut my scan-time, yet wasn’t appealing enough. It’s all about the looks now.

Iteration 4 -

Here is where I thought of Textual. And I asked for a service monitoring dashboard which did not look as plain as the JSON response above nor the Ascii checks . The result was a little error-ridden but this is where Knowing programming while 'vibe-coding' helps.

The changes I had to make were around providing the right command to obtain the statuses of different services, modifying the ports, fixing the styles etc.

After the manual fixes, which admittedly took lesser time than if I'd had to hand-code the whole script, the result was something like this -

NOT Rejected : PROGRESS. Now for the final lap!

Final set of iterations and the end result -

From here on, it was mostly smooth sailing.

I got ChatGPT to fix the universal status symbols to be indicators of Success and Failure - green and red dots, tweak the borders etc.

There were again, obvious AI-slop-ish errors in the code, which again, was fixable trivially.

All in all, the exercise took me less than an hour and I was very happy with it!

Next steps

- I'd like to make this an installer so that it can be easily installed without the dependency installation hassle.

- Want to implement an exponential retry and backoff when a service goes down

- ON/OFF controls for the services

References :

• ChatGippity (to hear Primeagen say it)

• https://textual.textualize.io/

• The Internet

Codebase -

All the code for this project, if you’d like to set it up, can be found here.

Thanks for reading Everything Python! Subscribe for free to receive new posts and support my work.

PS - At the time of this article, we’d just hit 600 readers! Thank you for being one of them!!

Share

I'm going to be presenting a talk at a Mongo DB User group meetup later today and I thought I'd write about it so that it would -

• serve as reading material for meetup attendees wanting to go through the content of my talk later

• let everyone else know what this is all about.

Let me pre-emptively say, I don't know why I chose this to be the "TITLE" of the talk. It is extremely dry. But the topic is actually a lot of fun!

Effectively, there is this concept called Change Streams in Mongo DB and this talk is an attempt to understand and illustrate its usage.

So first off, what is Mongo DB and where is it used?

MongoDB is a database that follows a document model to store data. This means that, in comparison to normal relational databases where data is stored using fixed schemas in rows and columns, Mongo DB and its other Document DB brethren store data in a more flexible format - in JSON-like documents.

Example of a dataset that can be stored in Mongo :

{
  "_id" : ObjectId(),
  "title" : "Anna Karenina",
  "author" : "Leo Tolstoy",
  "content" : "It's a classic of world literature, exploring themes of love, loyalty, family, and social class in 19th-century Russia.",
  "tags" : [ "Russian" , "Serious" ],
  "publishedDate" : ISODate()
},
{
  "_id" : ObjectId(),
  "title" : "War and Peace",
  "author" : "Leo Tolstoy",
  "content" : "Set during the Napoleonic Wars and focusing on several aristocratic families in Russia.",
  "tags" : [ "Russian", "Serious" ],
  "publishedDate" : ISODate()
}

MongoDB can be used where the data to be stored doesn't particularly benefit from being modelled into strict tables. It can be used when the data schema needs to be more flexible.

For example, the same data above could have potentially been stored in a Relational DB. But as the number of fields increases and as there end up being more and more complicated JOINS, the Relational DB model might suffer from slowdown.

What are Change Streams?

This is a feature that has been around for a long time now. We're currently on Mongo DB 8.0.4 as of December 2024 but this feature was introduced in MongoDB 3.6 in 2017.

It is used to let applications access real-time data changes in Mongo DB. Without having to keep polling for it.

Now other DBs also have this in some shape or form but they all vary in difficulty levels of configuration -

• Postgres apparently has support for a Debezium connector that can be used for Change Data Capture (CDC). Never tried it but I think I will after this!

• Amazon's DocumentDB also has Change Streams but it might need additional configuration compared to Mongo DB.

• Relational DBs can be configured to use Triggers or Log based CDC but it can impact performance or needs some non-trivial know-how.

In that aspect Change Streams are very easy to configure.

How do Change Streams work?

• This whole mechanism hinges on the fact that Mongo DB relies on "op-log" or operations-log based replication. An op-log is basically a record of all operations performed on data in any collection/database in MongoDB.

• What this means is that if Mongo DB is configured to use a replica set, any changes that are made to the DB are written to the op-log by the primary node. Secondary nodes read /tail the oplog and apply changes in the same order.

• Change Streams can be used by using a "watch" method on a collection, a database or a whole cluster.

• So now, whenever there's a certain operation-based change on the "system" under watch, the change stream captures it from the corresponding oplog entry.

• The operations supported are : insert, update, delete, replace , invalidate

How can I enable Change Streams?

This post assumes you have a working MongoDb setup - I'll write a separate post for this.

• Go to the Mongo Shell and execute rs.status()

If there's a replica set configuration like so -

you're all good. If not, you need to do the following :

• Stop the mongo service - Either from Task Manager if you're on Windows. Or using sudo systemctl stop mongod if on Linux.

• Find the mongod.cfg (Windows) or mongod.conf (Linux) file and add the following line

replication:
	  replSetName: "<Whatever name you want>"

So it looks like -

• Restart the Mongo service.

• Reopen the Mongo shell and run rs.initiate()

Boom! Change Streams are now enabled!

Great. Now how do I use them?

I thought about this a lot as well. My initial thought was to mimic the functioning of an oxymeter in a hospital that keeps reporting the oxygen level of a patient.

But I thought I'd keep it a little lighter.

So, my simulated use case is one of segregating News Items into 1 of 4 categories as they keep getting pulled from News Sources.

Here's a broad architecture diagram -

Let's consider this piece by piece :

News Generator :

• Here we have 5 "news sources", producing news items every, say 10 seconds.

• The item , which here is a string is sent to an Azure OpenAI LLM instance with a prompt designed to return the "Category" of News it belongs to. We have a preset expectation of news items to fall under 5 categories : "Sports", "Politics", "Entertainment", "Tech", "Misc".

  You don’t have to use Azure OpenAI. You can use any model you have access to!

• I'm using gpt-4o for this example but it's such a trivial activity that most older or any Small Local Model should also suffice for this task.

• What is not shown in the diagram is that I'm using Opik (launched locally) to track my LLM calls.

• Now as soon as this categorization is obtained, the data is pushed into a collection called "articles" under a DB called "newsDB".

The Flask App

• This doesn't necessarily have to be a Flask app. Pick your web server of choice - FastAPI, Django, Bottle, whatever you want. But yes, in this example, it is a flask app.

• Here, I do a few things :

  • Make sure the Mongo DB is connected to on port 27017 (default) and that the UI reflects the number of pre-existing records for each category in the DB. For a fresh start, that number is 0 for all categories.

  • Set up a collection.watch() on the articles collection so that the change stream can be captured.

  • Start the flask server using websockets (via flask-socketio) so that a steady, bidirectional connection is established between server and client. This way, the browser is always watching for any changes that the DB is ready to communicate back without needing a refresh of the screen.

The Client/ UI/ Browser

• If the server is started on say, port 5002, I navigate to http://localhost:5002

This changes automatically every 20 seconds (since that’s what I’ve configured underneath. You can set your own value.)

Because of Change Streams, with each article being produced and categorized, the DB’s state is Almost Immediately informed to the application.

This is something we'd have had to poll the DB regularly for, if this feature weren't there. And because we use websockets, the updated state of the DB can directly go from server to client I.e UI/the browser as well.

Now, are there any disadvantages to using Change streams? Absolutely. Since the op log is continuously, automatically being watched and tailed, there is a bit of a compute impact. But if the application demands near-realtime updates, that additional compute is the price to pay for the feature!

Hopefully this gave you an idea of how Change Streams can be used!

Codebase -

All the code for this project can be found here.

Why would I want to do this?

Fair question to ask in the face of so many ubiquitous LLM offerings present like ChatGPT, Claude, Gemini etc. Why do I even want to set up an LLM locally? I asked ChatGPT this and it told me a lot of what I was thinking along the lines of - like privacy, to prevent reliance on possibly unreliable internet and it kept going for a while, so I asked it to -

Setting up Ollama -

• Depending on your operating system, download the corresponding Ollama executable from the official website.

• Once you download and run it, it should be running as a small service in the background of your operating system. For example, if you're on Windows, you should be able to see it running on the tray on your screen's bottom right corner.

  If you’re on a Mac, it should show up on your Menu bar like so -

  

  • To test that it’s working, open up a CMD or a Terminal instance and type :

    • ollama -h

      

• To download any existing models, fetch them from the Ollama Models page and pull them locally using ollama run

• For example, I want to run one of the latest models - olmo2

  Once that model is pulled, the prompt looks a little like this -

  

• Smaller models are better for lower config laptops/desktops.

This section is optional.

The next thing to do to mimic a local Chat-GPT-ish experience is to hook this backend Ollama server to a front-end web interface. This is where https://openwebui.com/ comes in.

Setting up OpenWebUI -

The Github README for OpenWebUI is extremely helpful. A few months ago when I tried it out, they only had the Docker based offering but now it seems that all that is to be done to set it up is -

• Create and activate a virtual environment

• uv pip install open-webui

• open-webui serve

So when you visit localhost:8000 on your browser you should be able to see a chatgpt-ish interface and the list of models you downloaded on Ollama on a top-left corner dropdown.

Performance

• "How fast is it?", a friend asked. It's not going to be comparable to OpenAI/Claude/Gemini server speeds given that it is limited by your local laptop's CPU/GPU. But on a Mac M1 or a Windows i5 with 32 GB RAM, it's able to run and engage in processing and conversations at fairly decent, tolerable speeds.

What are my other options?

There's a couple of other options like LMStudio and Msty, but those are "left as an exercise to the reader" to try out. :D

Happy local chatting!

If you found this useful, please share it with your friends and ask them to subscribe to EverythingPython as well!

Subscribe now