What is PromQL?

PromQL (Prometheus Query Language) is the query language for retrieving and aggregating data in Prometheus.

Data types

Prometheus supports four data types (see Expression language data types):

Label matchers

Prometheus stores time series with labels. By specifying labels you can select specific series.

For example, to select only those with job="prometheus" for metric http_requests_total:

http_requests_total{job="prometheus"}

Available operators:

Metric types

Prometheus metrics come in four types:

For differences between Histogram and Summary, see HISTOGRAMS AND SUMMARIES. For latency calculation details, see this post (Japanese).

Aggregation

Use aggregation operators to aggregate vectors, e.g.:

• sum
• min
• max
• avg

Example: total HTTP requests

sum(http_requests_total)

Reference: Aggregation operators

Functions

PromQL provides many functions over time series. Functions accept either an instant vector or a range vector; the docs specify the type.

Examples:

• absent(v instant-vector) checks for the absence of elements.
• absent_over_time(v range-vector) checks absence over a range.
• exp(v instant-vector) computes the exponential.

See the official docs for more: functions.

rate / irate

rate and irate compute the per‑second increase of counter metrics.

rate(v range-vector) Average increase rate for slowly changing counters.

irate(v range-vector) Instantaneous rate for fast‑changing counters. Use this when spikes make rate hard to observe.

Counter reset Counters may reset on restart. When using rate or irate, resets are handled automatically. When aggregating, build on rate~/~irate to avoid reset artifacts. Example with sum:

sum(rate(http_request_total[5m]))

over_time aggregation functions

Functions of the form <aggregation>_over_time(range-vector) aggregate over time and return an instant vector.

References

Official Prometheus docs

What is Alertmanager?

Alertmanager sends alerts (e.g., email/Slack) when Prometheus metrics satisfy configured conditions.

Installation

You can spin up Prometheus with Docker Compose using this repo: → Install docker-compose

Start with:

$ git clone https://github.com/vegasbrianc/prometheus
$ cd prometheus
$ docker-compose up

Ports:

Slack notifications

Create a Slack app for Prometheus, enable Incoming Webhooks, and get the webhook URL.

Set username, channel, and api_url in alertmanager/config.yml:

route:
 receiver: 'slack'

receivers:
 - name: 'slack'
   slack_configs:
       - send_resolved: true
         username: '<username>'
         channel: '<channel name>'
         api_url: '<webhook url>'

Alertmanager configuration

Define alert rules like this:

groups:
- name: <rule name>
  rules:
  - alert: <alert name>
    expr: <PromQL expression>
    for: <duration>
    severity: <severity>
    annotations:
      description: "Alert description"
      summary: "Summary"

In this repo, rules live in prometheus/alert.rules.

To force an example alert, set expr to 1 as below:

groups:
- name: rule-example
  rules:
  - alert: alert-example
    expr: 1
    for: 1m

After editing, restart the Docker containers to apply changes. After a short wait, http://localhost:9090/alerts shows the alert as active.

Status is PENDING or FIRING; FIRING means the alert is firing.

Alertmanager shows fired alerts:

Slack also receives the notification:

References

• Intro to monitoring with Prometheus and Alertmanager (Japanese)
• Prometheus queries and alerting (Japanese)

Goal

Old issues often remain open. We want to close stale issues automatically.

Stale

Using Stale you can automatically mark and close inactive issues/PRs.

The GitHub Actions bot will mark items as stale like this (this example is configured to stale and close quickly for testing):

Installation steps

From the Actions tab of your repository, create a workflow from a template.

Scroll down to “Automate every step in your process” and select Stale.

Click “Set up this workflow” to open the editor.

By default issues go stale after 60 days and close 7 days later.

You can customize options. For example, to stale after 30 days and close after 5 days, write the following in .github/workflows/stale.yml:

name: Mark stale issues and pull requests

on:
  schedule:
  - cron: "30 1 * * *"

jobs:
  stale:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/stale@v3
      with:
        repo-token: ${{ secrets.GITHUB_TOKEN }}
        stale-issue-message: 'Stale issue message'
        stale-pr-message: 'Stale pull request message'
        stale-issue-label: 'no-issue-activity'
        stale-pr-label: 'no-pr-activity'
        days-before-stale: 30
        days-before-close: 5

See the README for additional settings.

Introduction

When you need to run code periodically, Cloud Functions for Firebase can help. It’s handy for tasks that must run at fixed times.

Use cases

• Aggregate Firestore user data once per day
• Delete obsolete data

How it works

Internally, the cron service Cloud Scheduler publishes a message to a Pub/Sub topic. A Cloud Function subscribes to that topic to schedule execution.

Installation

Switch to the Blaze plan

This isn’t available on the free plan; switch to the pay‑as‑you‑go Blaze plan.

Install tools

$ npm install -g firebase-tools

Log in:

$ firebase login

Initialize:

$ firebase init functions

Writing functions

To set a region, use functions.region. Example that runs every minute:

Intervals are specified using either the cron schedule format or the App Engine cron format.

exports.scheduledFunction = functions.region('asia-northeast1')
  .pubsub.schedule('every 1 minutes')
  .timeZone('Asia/Tokyo')
  .onRun(() => {
    console.info('hello world');
  });

Deploy:

$ firebase deploy --only functions

After deployment, the scheduled job appears under Functions as shown below.

References

Official Firebase docs (Japanese)