Today's Deep-Dive: GlitchTip

Welcome back to the deep dive.

This is the show where we cut through all the noise

and get you the insights you actually need.

Okay, picture this for a second.

You've just launched your amazing new app, right?

And bam, error messages start flooding in, total scramble.

Trying to figure out what's breaking,

where it's breaking, why it's stressful.

And that feeling, that chaos,

that's exactly where something like Glitchtip comes in.

Think of it as your digital lifeguard.

So today we're doing a deep dive into Glitchtip.

It's this powerful open-source tool

for tracking software errors.

And it promises to make that whole messy job simpler.

Our mission for you, our listener,

is pretty straightforward.

We want you to understand what Glitchtip is, sure,

but crucially, how to get it up and running.

Especially if you've never set up

this kind of software before.

We're aiming for a really

beginner-friendly introduction here.

Let's demystify it, but hang on.

Before we jump in, just a quick word from our supporter.

This deep dive is brought to you by safeserver.de.

These guys are experts in hosting software

and really helping with your digital transformation journey.

You can find out more about how they can help you

over at www.safeserver.de.

Check them out.

Okay, let's unpack this thing.

Expert, maybe start us off.

From your perspective,

what's the immediate, like, tangible win

for someone using a tool like Glitchtip?

Especially if they're just starting out.

Yeah, that's a good way to put it.

I mean, for me, it's about moving away

from just guessing blindly.

It helps you get to informed action, you know?

It takes what often feels like this chaotic mess

of bugs and turns it into something clear,

a roadmap you can actually act on.

So instead of just reacting when users complain,

Glitchtip lets you proactively spot and fix things,

often before they become big problems.

It really is a shortcut to understanding

what's actually happening inside your application.

It's health, basically.

Right, so it's about getting control,

getting some foresight, it's huge.

So, okay, at its heart,

Glitchtip collects errors in real time, right?

And monitors things.

It's built to grab every single error from your project,

organize those pesky bugs into something useful,

and then shoot you alerts when and where you need them.

And what's really neat is its compatibility

with Sentry client SDKs.

Think of those SDKs as like pre-made kits,

little libraries, that let your app easily send

error data and performance info

to a monitoring service like Glitchtip.

So if you happen to be using Sentry already,

or maybe you want that kind of flexibility down the road,

Glitchtip just slots right in.

And the big selling point seems to be

that it's easier to run

and just simple open source error tracking.

Glitchtip seems to focus on three main things

to keep your software happy.

First up, error tracking.

This is like its main job, right?

It reports all those exceptions,

you know, the unexpected crashes,

along with important log messages,

or even things like content security policy violations.

Right, those CSP violations,

they're like browser security guards stopping dodgy stuff.

Exactly, and it pulls all that info

into one central spot so you can quickly see

what went wrong and, you know, fix it.

Okay, second thing.

Application performance monitoring, APM.

This sounds great for finding those bottlenecks

where your app is dragging its feet.

Yeah, performance is key.

And Glitchtip seems to take

this works out of the box approach,

meaning you don't have to spend ages

building dashboards or hunting metrics.

Right, it tries to surface

the important stuff automatically.

Yeah, it just helps you find

like your slowest web requests,

maybe database calls taking too long,

other slow transactions,

stuff that annoys users.

Exactly, user experience impact.

And finally, number three, uptime monitoring.

That sounds pretty self-explanatory.

Glitchtip can basically ping your site regularly.

Like a little hello you there.

Yeah, and it'll warn you

if it doesn't get a response.

Or you can flip it, right?

Your app sends Glitchtip a scheduled

I'm alive signal.

A heartbeat, yeah.

And if Glitchtip doesn't get that ping on time,

boom, alert via email or webhook.

I've heard horror stories,

the site's going down for hours

because nobody was watching.

How crucial is this uptime piece

for, say, smaller teams or solo devs?

Oh, it's absolutely vital.

It's like that silent and guardian always watching.

Imagine, yeah, your web server just quietly dies

at 3 a.m. without uptime monitoring.

You might not know till 9 a.m. when a customer calls.

Right.

You've just lost six hours of potential business,

damaged your reputation.

Glitchtip's simple ping or receiving that heartbeat,

it can honestly be the difference

between a tiny blip and a major headache.

It just adds that layer of professionalism,

of reliability, super important.

And, you know, beyond just the features,

it's worth hitting on Glitchtip's core values again.

Simplicity, affordability,

and that freedom you get with open source.

Right, the open source aspect.

Yeah, meaning you can see the code, change it,

use it however you want.

That gives you a level of control and transparency

you often just don't get

with closed source proprietary stuff.

What's really interesting about Glitchtip, I think,

beyond just having similar features to bigger players,

is how it sort of challenges that typical sauce model

by offering a fully featured self-hosted option.

See, lots of projects have a free tier,

but then they lock the good stuff behind a paywall, right?

Glitchtip really commits to keeping all features available

even if you run it yourself.

That's a really good point about transparency and control.

Definitely appealing.

And just to quickly clarify something

they mentioned a lot in the docs, events.

An event is basically just one time

your project sends data to Glitchtip.

That's it.

Simple as that.

Yeah, so if 10 different users hit the exact same bug,

Glitchtip gets 10 separate events.

Right, helps you gauge the impact.

Is it one person, or is it widespread?

Exactly.

OK.

OK, so now we know what it is and why it's useful.

Let's talk about actually getting it.

How do you get your hands on Glitchtip?

There are basically two main routes,

and they cater to different comfort levels, different needs.

First up is the hosted version.

This is super straightforward.

You just go sign up at app.glitchtip.com, and boom,

they handle all the server stuff, the infrastructure,

all of it.

Like renting a furnished apartment, yeah.

Move in, ready.

Perfect analogy.

All the maintenance is done for you.

They've got different price tiers.

There's a free plan, up to 1,000 events a month,

error tracking, unlimited projects,

unlimited team members, pretty generous.

That's a good starting point for small projects.

Totally.

Then it scales up.

Smallest $15 a month for 100K events,

medium is $50 for 500K, large is $250 for up to 3 million

events a month.

And they even have discounted plans for nonprofits

and open source projects, starting at just $5 a month.

That's great to see, supporting the community.

Yeah.

So that's option one, easy peasy hosted.

Option two, and this is what we'll

focus on more today for our beginner-friendly angle,

is the self-hosted version.

This means you run Glitchtip on your own server.

And the core software itself, it's free.

And this choice, hosted versus self-hosted,

is really key for you, the listener, especially

if you're learning.

Hosted gives you that instant gratification, zero setup

hassle, die right into tracking errors.

Self-hosting, though, that gives you total control

over your data, no limits on events,

and it really fits that open source spirit

of ownership customization.

Right.

So it's about picking what fits you best right now,

your comfort zone, your goals, how much you

want to tinker under the hood.

Exactly.

And if you are just dipping your toes in,

maybe thinking about self-hosting,

we'll walk you through the simplest ways.

The docs actually point out several paths

that make it surprisingly doable,

even if you're not some command line wizard.

OK.

So let's get into those accessible self-hosting options.

The easiest grouts, especially for beginners,

use tools that really simplify things.

First one they recommend is Docker Compose.

Imagine you need several bits of software working together,

Glitchtip, its database, maybe something else.

Like a little team of applications.

Yeah.

Docker Compose lets you define and run

that whole team as one single thing using simple commands,

usually on one server.

It packages everything up nicely.

Right.

The steps are pretty clean.

Install Docker and Docker Compose.

Those are tools for running software

in these isolated packages called containers.

You copy a sample config file, docker-compose.sample.iml,

onto your server.

You edit the environment part.

We'll get to those settings in a sec.

And then you just start it with Docker Compose up AED.

And out of D just means run it in the background.

Exactly.

Now, that gets it running.

But there's a crucial next step, the doc stress.

Setting up SSL for security.

Expert, why is getting that HTTPS lock icon

so vital right away, especially for error tracking?

Oh, it's absolutely critical.

SSL, or TLS these days, encrypts the connection between,

say, your application sending the error

and your GlitchTip server.

Think of it like a secure private pipe for that data.

You're potentially sending sensitive stuff

about your application's inner workings, maybe parts

of stack traces, logs.

Without SSL, TLS, that data is flying across the internet

in plain text.

Anyone could potentially grab it and read it.

Yikes, not good.

Not good at all.

So setting up SSL, often using something like Jinx or Apache

as a proxy, and maybe let's encrypt with StartBot

to get free certificates.

It's just non-negotiable.

Security 101.

Makes total sense.

Security first, always.

OK, so besides Docker Compose, there are also

these managed hosting providers.

These sound really beginner-friendly

because they basically handle almost all the server

stuff for you.

Updates, maintenance, the works.

Taking the infrastructure burden off your shoulders.

Exactly.

The docs mention a few.

Peekapods, described as affordable, managed hosting,

aimed right at running open source apps like Glitchtip.

You sign up, punch in a few settings, they handle the rest.

Nice and simple.

Then there's Elestio.

Another managed provider, supports multiple clouds,

and apparently comes with email server support built in,

which is a big plus for setup.

Oh, that could save some hassle with the email config.

Yeah, they say they handle configuring and upgrading

Glitchtip by default, too.

And finally, Notion.

Similar deal.

Easy deployment, management, automated backups, monitoring.

And interestingly, Elestio, Peekapods, and Notion

all support Glitchtip through a revenue share program.

So using them also supports the Glitchtip project itself.

Yeah, it seems like a neat way to contribute back

just by choosing your host.

You know, what's really impressive here

is how these managed options make powerful tools

like Glitchtip genuinely accessible.

Even if you don't know much about servers or Linux,

you can still use this professional-grade error

tracking.

It massively lowers that barrier to entry.

You can focus on the output fixing bugs,

improving your app instead of getting totally bogged down

in the input of managing servers.

It's a fantastic bridge for learners.

Totally agree.

Now, even with these easier options,

it's probably good to have a rough idea of the core system

needs if you do self-host, maybe with Docker Compose.

Glitchtip needs PostgreSQL version 14 or newer.

That's the main database where all the error details load.

The main data store, yeah.

It also needs Redis or Valky.

These are like super fast temporary storage caches

helping Glitchtip process things quickly.

For performance, mostly.

Right.

Then you need a web service that serves the Glitchtip pages

to your browser and a worker service that handles background

stuff, like sending those alerts.

Resource-wise, they recommend about 1 GB of RAM,

a standard by 86 or ARM64 CPU, and maybe 30 GB of the disk

base, if you expect around a million events a month.

Pretty modest, really.

Yeah, not too demanding for many basic setups.

Now, just for context, the docs do

mention more advanced stuff, like using

Helm for Kubernetes or the Digital Ocean App Platform.

Right, getting to orchestration territory.

Exactly.

Kubernetes is complex, designed for managing

lots of containers across many servers.

Helm is its package manager.

Definitely not the beginner path.

No way.

That's for high traffic sites or people already

deep into that ecosystem.

And they explicitly say the installing without Docker

method is not recommended for beginners.

Yeah, that requires knowing Django, Celery, web servers,

SSL, config.

It's a lot.

Way too much for starting out.

We're sticking to the easier routes today.

OK, so you've picked your path, Docker Compose, maybe

a managed host.

The next absolutely critical step is configuration.

Glitchtip needs environment variables.

Think of these as settings you give the application.

Little instructions, basically.

Yeah, telling it how to act, where to find things,

how to keep itself secure.

Let's focus on the required ones.

The absolute must-haves to get a working Glitchtip instance.

First, secret key.

This needs to be set to just any random long string

of characters.

Don't reuse it from somewhere else, make it unique.

Good point.

Super important for security, used for crypto stuff,

session signing, then email setup,

because you want alerts, right?

Kind of the whole point.

So you either provide an email URL.

That's an SMTP string, simple mail transfer protocol,

how email servers talk.

It looks like smtp.user.password at server.port.

Or you can use a service like Mailgun or SendGrid.

Right, dedicated email delivery services.

Yeah, you give it their API key and set the email

back end variable to match the service you're using.

You also just set a default from mail,

like norplyatyourdomain.com or something.

So people know where the alerts are coming from.

And finally, the glithtp domain.

This has to be your actual domain,

including the HTTPS dot, or HTTP part.

So, HTTPS.glitchtip.mycoolapp.com.

And this brings up a good point.

Why are these specific ones so crucial?

Well, the secret key is like your instance's

unique fingerprint, vital for security,

preventing data tampering.

Can't skip it.

Yeah.

Email settings.

Well, Glitchtip needs to send alerts and notifications, right?

If it can't send email, it's severely crippled.

That's a primary function.

Makes sense.

And the dithtp domain tells the application

where it lives on the internet.

It needs this to build correct links in emails,

for integrations, just to operate properly.

So yeah, getting these core ones right

is absolutely foundational.

They're the non-negotiables for a stable, secure, working

setup.

Got it.

Non-negotiables.

And speaking of variables, there's this one unique,

optional one that jumped out.

I paid for Glitchtip.

Oh, yeah.

What's that do?

Well, setting it to true doesn't actually

unlock any extra features on your self-hosted instance.

But the docs say setting it enables our team

to continue building Glitchtip.

It helps fund the developers, designers, even

their own free tier hosting.

Ah, so it's like a voluntary support flag.

Exactly.

They suggest maybe donating $5 per month per user

if you're self-hosting.

It's just a cool, transparent way

to support the project if you find it valuable.

That's a nice touch.

Respectful way to ask for support for open source.

Yeah, I thought so too.

OK, so while our main goal today was getting you started,

it's probably worth just peeking ahead a little.

What happens when you get more comfortable or your needs grow?

Glitchtip actually has quite a bit

of flexibility under the hood.

Room to grow, basically.

Right.

For instance, file storage.

By default, with Docker, it might store stuff locally,

which is fun to start.

But as you scale, or if you need better backups,

you can configure a Glitchtip to use remote object storage.

Like S3 or Google Cloud Storage.

Exactly.

AWS S3, Digital Ocean Spaces, Azure Blob Storage,

Google Cloud Storage.

Just set a few more environment variables,

like default file storage, RSCID, et cetera.

That's huge for scalability and resilience.

Means your data isn't tied to just one server.

Yeah, great for backups and not losing data

if a server goes down.

And another thing we can briefly mention

is social authentication, OAuth setup.

Letting users log in with, like, Google or GitHub.

Precisely.

Through the Django admin interface,

which is part of Glitchtip, you can set up integrations

with loads of providers.

Digital Ocean, GitEa, GitHub, GitLab, Google, Microsoft,

Nextcloud, even generic OpenID Connect.

Wow, that's comprehensive.

Yeah.

So your team can just log into Glitchtip

using their existing work accounts.

Super convenient, streamlines user management a lot.

You know, connecting this back to the bigger picture,

these advanced options really showcase Glitchtip's

flexibility.

They might not be things you touch on day one, absolutely

not, but they clearly show that this platform isn't

just a basic tool.

It can grow with you.

It offers serious solutions for scaling up,

for handling data robustly, for managing users effectively

down the road.

It really speaks to the thoughtful design

behind the open source project.

Yeah, that's a great way to put it.

It shows depth.

OK, well, that pretty much brings us to the end of our deep dive

for today we've covered a lot.

From figuring out what Glitchtip actually

is this open source tool for error tracking performance

uptime to navigating those choices, hosted or self-hosted,

and digging into the easiest self-hosting paths,

and even tackling those essential configuration

variables to get you started smoothly as a beginner.

Hopefully, you're feeling a lot more

confident about bringing this kind of tool into your world.

So thinking about it all, what really

stands out to you, the listener, Glitchtip obviously

offers powerful error tracking features.

But maybe its real strength, especially for someone learning,

is that whole spectrum of deployment options.

From totally managed hand-holding services

to the more hands-on but still accessible Docker Compose

route, it really lets you choose your own adventure,

your level of technical deep dive,

as you get more comfortable.

It's like an open invitation to explore and grow your skills

while solving a real problem.

It's about taking control.

Yeah, well said.

So what does this all boil down to?

It means you've got choices.

You've got a powerful open source ally

ready to help keep your software running smoothly, efficiently.

Whether you're a coding veteran or literally just

launching your first project and wondering how to manage it,

Glitchtip offers a path forward for you.

And hey, remember, this deep dive

was supported by our friends at safeserver.de.

They're your partners for software hosting

and that whole digital transformation journey.

Check them out at www.safeserver.de to learn more.

Thank you so much for joining us on this deep dive today.

We really hope you feel informed and maybe even a bit

excited to explore Glitchtip for yourself.

and we'll catch you on the next deep dive.

and we'll catch you on the next deep dive.