feat(cdp): add ip anon transformation

plugin-server/src/cdp/templates/_transformations/ip-anonymization/ip-anonymization.template.test.ts

@@ -0,0 +1,97 @@
+import { HogFunctionInvocationGlobals } from '../../../types'
+import { TemplateTester } from '../../test/test-helpers'
+import { template } from './ip-anonymization.template'
+
+describe('ip-anonymization.template', () => {
+    const tester = new TemplateTester(template)
+    let mockGlobals: HogFunctionInvocationGlobals
+
+    beforeEach(async () => {
+        await tester.beforeEach()
+    })
+
+    it('should anonymize IPv4 address by zeroing last octet', async () => {
+        mockGlobals = tester.createGlobals({
+            event: {
+                properties: {
+                    $ip: '89.160.20.129',
+                },
+            },
+        })
+
+        const response = await tester.invoke({}, mockGlobals)
+
+        expect(response.finished).toBe(true)
+        expect(response.error).toBeUndefined()
+        expect(response.execResult).toMatchObject({
+            properties: {
+                $ip: '89.160.20.0',
+            },
+        })
+    })
+
+    it('should handle event with no IP address', async () => {
+        mockGlobals = tester.createGlobals({
+            event: {
+                properties: {},
+            },
+        })
+
+        const response = await tester.invoke({}, mockGlobals)
+
+        expect(response.finished).toBe(true)
+        expect(response.error).toBeUndefined()
+        expect(response.execResult).toMatchObject({
+            properties: {},
+        })
+    })
+
+    it('should handle invalid IP address format', async () => {
+        mockGlobals = tester.createGlobals({
+            event: {
+                properties: {
+                    $ip: '89.160.20', // Invalid IP - missing octet
+                },
+            },
+        })
+
+        const response = await tester.invoke({}, mockGlobals)
+
+        expect(response.finished).toBe(true)
+        expect(response.error).toBeUndefined()
+        // Should return unchanged event when IP format is invalid
+        expect(response.execResult).toMatchObject({
+            properties: {
+                $ip: '89.160.20',
+            },
+        })
+    })
+
+    it('should handle various IPv4 formats', async () => {
+        const testCases = [
+            { input: '192.168.1.1', expected: '192.168.1.0' },
+            { input: '10.0.0.255', expected: '10.0.0.0' },
+            { input: '172.16.254.1', expected: '172.16.254.0' },
+        ]
+
+        for (const testCase of testCases) {
+            mockGlobals = tester.createGlobals({
+                event: {
+                    properties: {
+                        $ip: testCase.input,
+                    },
+                },
+            })
+
+            const response = await tester.invoke({}, mockGlobals)
+
+            expect(response.finished).toBe(true)
+            expect(response.error).toBeUndefined()
+            expect(response.execResult).toMatchObject({
+                properties: {
+                    $ip: testCase.expected,
+                },
+            })
+        }
+    })
+})

plugin-server/src/cdp/templates/_transformations/ip-anonymization/ip-anonymization.template.ts

@@ -0,0 +1,47 @@
+import { HogFunctionTemplate } from '../../types'
+
+export const template: HogFunctionTemplate = {
+    free: true,
+    status: 'alpha',
+    type: 'transformation',
+    id: 'template-ip-anonymization',
+    name: 'IP Anonymization',
+    description:
+        'This transformation sets the last octet of an IP address to zero (e.g., 12.214.31.144 → 12.214.31.0), protecting user privacy and reducing disclosure risk.',
+    icon_url: '/static/hedgehog/builder-hog-01.png',
+    category: ['Custom'],
+    hog: `
+// Check if the event has an IP address
+if (empty(event.properties?.$ip)) {
+    print('No IP address found in event')
+    return event
+}
+
+let ip := event.properties.$ip
+let parts := splitByString('.', ip)
+
+// Check if we have a valid IPv4 address
+if (length(parts) = 4) {
+    // Replace the last octet with '0'
+    let anonymizedIp := concat(
+        parts[1], 
+        '.', 
+        parts[2], 
+        '.', 
+        parts[3], 
+        '.0'
+    )
+
+    let returnEvent := event
+    returnEvent.properties.$ip := anonymizedIp
+
+    print('Anonymized IP', ip, '->', anonymizedIp)
+    return returnEvent
+}
+
+// If we don't have a valid IPv4, return original event
+print('Invalid IPv4 address format:', ip)
+return event
+    `,
+    inputs_schema: [],
+}

plugin-server/src/cdp/templates/index.ts

@@ -2,13 +2,15 @@ import { DESTINATION_PLUGINS, TRANSFORMATION_PLUGINS } from '../legacy-plugins'
 import { template as webhookTemplate } from './_destinations/webhook/webhook.template'
 import { template as defaultTransformationTemplate } from './_transformations/default/default.template'
 import { template as geoipTemplate } from './_transformations/geoip/geoip.template'
+import { template as ipAnonymizationTemplate } from './_transformations/ip-anonymization/ip-anonymization.template'
 import { HogFunctionTemplate } from './types'
 
 export const HOG_FUNCTION_TEMPLATES_DESTINATIONS: HogFunctionTemplate[] = [webhookTemplate]
 
 export const HOG_FUNCTION_TEMPLATES_TRANSFORMATIONS: HogFunctionTemplate[] = [
     defaultTransformationTemplate,
     geoipTemplate,
+    ipAnonymizationTemplate,
 ]
 
 export const HOG_FUNCTION_TEMPLATES_DESTINATIONS_DEPRECATED: HogFunctionTemplate[] = DESTINATION_PLUGINS.map(