feat: allow math expressions for time and duration (#24453)

Description: Allows addition and subtraction between times and duration
according to rules in #22009

Link to tracking Issue: Closes #22009

Testing: Unit testing for math operations

Documentation:

---------

Co-authored-by: Tyler Helmuth <[email protected]>
Co-authored-by: Evan Bradley <[email protected]>

Author: 3 people

.chloggen/feat_math-time-duration.yaml

@@ -0,0 +1,20 @@
+# Use this changelog template to create an entry for release notes.
+# If your change doesn't affect end users, such as a test fix or a tooling change,
+# you should instead start your pull request title with [chore] or use the "Skip Changelog" label.
+
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: 'enhancement'
+
+# The name of the component, or a single word describing the area of concern, (e.g. filelogreceiver)
+component: 'pkg/ottl'
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: 'Add support for using addition and subtraction with time and duration'
+
+# Mandatory: One or more tracking issues related to the change. You can use the PR number here if no issue exists.
+issues: [22009]
+
+# (Optional) One or more lines of additional information to render under the primary note.
+# These lines will be padded with 2 spaces and then inserted directly into the document.
+# Use pipe (|) for multiline entries.
+subtext:

pkg/ottl/README.md

@@ -172,9 +172,18 @@ When defining an OTTL function, if the function needs to take an Enum then the f
 
 Math Expressions represent arithmetic calculations.  They support `+`, `-`, `*`, and `/`, along with `()` for grouping.
 
-Math Expressions currently only support `int64` and `float64`.
+Math Expressions currently support `int64`, `float64`, `time.Time` and `time.Duration`. 
+For `time.Time` and `time.Duration`, only `+` and `-` are supported with the following rules: 
+  - A `time.Time` `-` a `time.Time` yields a `time.Duration`.
+  - A `time.Duration` `+` a `time.Time` yields a `time.Time`. 
+  - A `time.Time` `+`  a `time.Duration` yields a `time.Time`.
+  - A `time.Time` `-`  a `time.Duration` yields a `time.Time`.
+  - A `time.Duration` `+` a `time.Duration` yields a `time.Duration`.
+  - A `time.Duration` `-` a `time.Duration` yields a `time.Duration`.
+
 Math Expressions support `Paths` and `Editors` that return supported types.
 Note that `*` and `/` take precedence over `+` and `-`.
+Also note that `time.Time` and `time.Duration` can only be used with `+` and `-`. 
 Operations that share the same level of precedence will be executed in the order that they appear in the Math Expression.
 Math Expressions can be grouped with parentheses to override evaluation precedence.
 Math Expressions that mix `int64` and `float64` will result in an error.

pkg/ottl/math.go

@@ -6,6 +6,7 @@ package ottl // import "github.com/open-telemetry/opentelemetry-collector-contri
 import (
 	"context"
 	"fmt"
+	"time"
 )
 
 func (p *Parser[K]) evaluateMathExpression(expr *mathExpression) (Getter[K], error) {
@@ -98,14 +99,68 @@ func attemptMathOperation[K any](lhs Getter[K], op mathOp, rhs Getter[K]) Getter
 					default:
 						return nil, fmt.Errorf("%v must be int64 or float64", y)
 					}
+				case time.Time:
+					return performOpTime(newX, y, op)
+				case time.Duration:
+					return performOpDuration(newX, y, op)
 				default:
-					return nil, fmt.Errorf("%v must be int64 or float64", x)
+					return nil, fmt.Errorf("%v must be int64, float64, time.Time or time.Duration", x)
 				}
 			},
 		},
 	}
 }
 
+func performOpTime(x time.Time, y any, op mathOp) (any, error) {
+	switch op {
+	case ADD:
+		switch newY := y.(type) {
+		case time.Duration:
+			result := x.Add(newY)
+			return result, nil
+		default:
+			return nil, fmt.Errorf("time.Time must be added to time.Duration; found %v instead", y)
+		}
+	case SUB:
+		switch newY := y.(type) {
+		case time.Time:
+			result := x.Sub(newY)
+			return result, nil
+		case time.Duration:
+			result := x.Add(-1 * newY)
+			return result, nil
+		default:
+			return nil, fmt.Errorf("time.Time or time.Duration must be subtracted from time.Time; found %v instead", y)
+		}
+	}
+	return nil, fmt.Errorf("only addition and subtraction supported for time.Time and time.Duration")
+}
+
+func performOpDuration(x time.Duration, y any, op mathOp) (any, error) {
+	switch op {
+	case ADD:
+		switch newY := y.(type) {
+		case time.Duration:
+			result := x + newY
+			return result, nil
+		case time.Time:
+			result := newY.Add(x)
+			return result, nil
+		default:
+			return nil, fmt.Errorf("time.Duration must be added to time.Duration or time.Time; found %v instead", y)
+		}
+	case SUB:
+		switch newY := y.(type) {
+		case time.Duration:
+			result := x - newY
+			return result, nil
+		default:
+			return nil, fmt.Errorf("time.Duration must be subtracted from time.Duration; found %v instead", y)
+		}
+	}
+	return nil, fmt.Errorf("only addition and subtraction supported for time.Time and time.Duration")
+}
+
 func performOp[N int64 | float64](x N, y N, op mathOp) (N, error) {
 	switch op {
 	case ADD: