MongoDB $log Operator

What You’ll Learn

The $log operator calculates the logarithm of a number in a specified base. Unlike $ln (which always uses base e), $log lets you choose base 10, base 2, or any other valid base.

Definition and Usage

In MongoDB’s aggregation framework, the $log operator computes logbase(number) — the power you must raise the base to in order to get the number. For example, log₁₀(100) = 2 because 10² = 100, and log₂(8) = 3 because 2³ = 8.

Use $log when your formula requires a specific logarithm base. For natural logarithms (base e), use $ln instead. For base 10 only, you can also use the dedicated $log10 operator.

📝 Syntax

The $log operator takes a two-element array: number and base.

{ $log: [ <number>, <base> ] }

Common Patterns

// Log base 10 of a field
{ $log: [ "$quantity", 10 ] }

// Log base 2 of a literal
{ $log: [ 8, 2 ] }

// Both arguments from fields
{ $log: [ "$value", "$logBase" ] }

Syntax Rules

• Array form — $log requires [ number, base ], not an object.
• <number> — must be a positive number (or null → null).
• <base> — must be positive and cannot equal 1.
• logb(1) = 0 — for any valid base, the log of 1 is zero.
• Use inside stages like $project, $addFields, or $set.
• For base e, prefer $ln; for base 10, consider $log10.

Examples Gallery

Walk through an orders collection and compute logarithms with different bases using $project.

[
  { "_id": ObjectId("609c26812e9274a86871bc6a"), "item": "Widget A", "quantity": 10 },
  { "_id": ObjectId("609c26812e9274a86871bc6b"), "item": "Widget B", "quantity": 100 },
  { "_id": ObjectId("609c26812e9274a86871bc6c"), "item": "Widget C", "quantity": 1000 }
]

db.orders.aggregate([
  {
    $project: {
      item: 1,
      quantity: 1,
      logQuantity: {
        $log: [ "$quantity", 10 ]
      }
    }
  }
])

// Widget A (10)    → logQuantity: 1     (10¹ = 10)
// Widget B (100)   → logQuantity: 2     (10² = 100)
// Widget C (1000)  → logQuantity: 3     (10³ = 1000)

db.orders.aggregate([
  {
    $project: {
      item: 1,
      quantity: 1,
      log2Quantity: {
        $log: [ "$quantity", 2 ]
      }
    }
  }
])

// Widget A (10)    → log2Quantity: ≈ 3.322  (2³.³²² ≈ 10)
// Widget B (100)   → log2Quantity: ≈ 6.644  (2⁶.⁶⁴⁴ ≈ 100)
// Widget C (1000)  → log2Quantity: ≈ 9.966  (2⁹.⁹⁶⁶ ≈ 1000)

db.orders.aggregate([
  {
    $project: {
      item: 1,
      quantity: 1,
      logBase10: {
        $log: [ "$quantity", 10 ]
      },
      naturalLog: {
        $ln: "$quantity"
      }
    }
  }
])

// Widget A (10):
//   logBase10: 1
//   naturalLog: 2.302585

// Widget B (100):
//   logBase10: 2
//   naturalLog: 4.605170

db.orders.aggregate([
  {
    $project: {
      item: 1,
      quantity: 1,
      safeLog: {
        $cond: [
          { $gt: [ "$quantity", 0 ] },
          { $log: [ "$quantity", 10 ] },
          null
        ]
      }
    }
  }
])

db.scales.aggregate([
  {
    $project: {
      label: 1,
      result: {
        $log: [ "$value", "$base" ]
      }
    }
  }
])

// Example document:
// { value: 64, base: 4 } → result: 3  (4³ = 64)

🚀 Use Cases

• Scaling data — compress values that span many orders of magnitude onto a readable log scale.
• Normalization — transform skewed distributions before analysis or machine learning.
• Performance metrics — convert exponential growth curves into linear trends for comparison.
• Custom bases — compute log base 2, base 4, or any domain-specific base in one expression.

💡 Best Practices