MongoDB $second Operator

What You’ll Learn

The $second operator extracts the seconds portion (0–59) from a BSON Date inside MongoDB aggregation pipelines. Use it for log timing analysis, sub-minute patterns, latency bucketing, and precise time breakdowns.

Definition and Usage

In MongoDB’s aggregation framework, the $second operator takes a date expression and returns an integer between 0 and 59. For example, $second applied to ISODate("2024-06-15T14:30:45Z") returns 45, and ISODate("2024-06-15T09:05:07Z") returns 7.

Seconds sit between $minute and $millisecond in MongoDB’s date-extraction family. Together with $hour and $minute, they let you break any timestamp into readable parts for filtering, grouping, or display.

📝 Syntax

The $second operator takes a date expression, or an object with date and timezone:

{ $second: <dateExpression> }

// With timezone:
{
  $second: {
    date: <dateExpression>,
    timezone: <tz>
  }
}

Syntax Rules

• Argument — any expression that evaluates to a BSON Date (field, $$NOW, or literal).
• Return value — integer from 0 to 59 (seconds within the minute).
• Null input — returns null when the date is null or missing.
• Timezone — optional; use Olson timezone IDs like "Europe/London".
• Use inside $project, $addFields, $set, $match (with $expr), or $group.

Examples Gallery

Extract seconds from log timestamps, find events at the start of a minute, group request bursts by second, and read seconds in a local timezone.

[
  {
    "_id": 1,
    "path": "/api/users",
    "loggedAt": ISODate("2024-06-15T14:30:45Z")
  },
  {
    "_id": 2,
    "path": "/api/orders",
    "loggedAt": ISODate("2024-06-15T09:05:07Z")
  },
  {
    "_id": 3,
    "path": "/health",
    "loggedAt": ISODate("2024-06-15T10:00:00Z")
  }
]

db.requests.aggregate([
  {
    $project: {
      path: 1,
      loggedAt: 1,
      second: { $second: "$loggedAt" }
    }
  }
])

{ "path": "/api/users",  "second": 45 }
{ "path": "/api/orders", "second": 7 }
{ "path": "/health",     "second": 0 }

db.requests.find({
  $expr: {
    $eq: [
      { $second: "$loggedAt" },
      0
    ]
  }
})

{ "path": "/health", "loggedAt": "2024-06-15T10:00:00.000Z" }

db.requests.aggregate([
  {
    $group: {
      _id: { $second: "$loggedAt" },
      count: { $sum: 1 }
    }
  },
  { $sort: { "_id": 1 } }
])

db.requests.aggregate([
  {
    $project: {
      path: 1,
      loggedAt: 1,
      secondUtc: { $second: "$loggedAt" },
      secondPacific: {
        $second: {
          date: "$loggedAt",
          timezone: "America/Los_Angeles"
        }
      }
    }
  }
])

// loggedAt: 2024-06-15T14:30:45Z
// secondUtc: 45; secondPacific may differ near zone boundaries

db.requests.aggregate([
  {
    $project: {
      path: 1,
      loggedAt: 1,
      timeParts: {
        hour: { $hour: "$loggedAt" },
        minute: { $minute: "$loggedAt" },
        second: { $second: "$loggedAt" }
      }
    }
  }
])

// 14:30:45 UTC → { hour: 14, minute: 30, second: 45 }

🚀 Use Cases

• Log timing — analyze when within each minute events occur.
• Sub-minute bursts — group high-frequency data by second for spike detection.
• Cron alignment — find jobs or heartbeats that fire at second 0.
• Time breakdowns — combine with $hour and $minute for display or reporting.

💡 Best Practices