From 32d2f60f8aec4d2a2291c67a508c9796cb74bf82 Mon Sep 17 00:00:00 2001
From: Luca Cavanna <javanna@users.noreply.github.com>
Date: Tue, 10 Aug 2021 14:07:53 +0200
Subject: [PATCH] Emit multiple fields from a runtime field script (#75108)

We have recently introduced support for grok and dissect to the runtime fields
Painless context that allows to split a field into multiple fields. However, each runtime
field can only emit values for a single field. This commit introduces support for emitting
multiple fields from the same script.

The API call to define a runtime field that emits multiple fields is the following:

```
PUT localhost:9200/logs/_mappings
{
    "runtime" : {
      "log" : {
        "type" : "composite",
        "script" : "emit(grok(\"%{COMMONAPACHELOG}\").extract(doc[\"message.keyword\"].value))",
        "fields" : {
            "clientip" : {
                "type" : "ip"
            },
            "response" : {
                "type" : "long"
            }
        }
      }
    }
}
```

The script context for this new field type accepts two emit signatures:

* `emit(String, Object)`
* `emit(Map)`

Sub-fields need to be declared under fields in order to be discoverable through
the field_caps API and accessible through the search API.

The way that it emits multiple fields is by returning multiple MappedFieldTypes
from RuntimeField#asMappedFieldTypes. The sub-fields are instances of the
runtime fields that are already supported, with a little tweak to adapt the script
defined by their parent to an artificial script factory for each of the sub-fields
that makes its corresponding sub-field accessible. This approach allows to reuse
all of the existing runtime fields code for the sub-fields.

The runtime section has been flat so far as it has not supported objects until now.
That stays the same, meaning that runtime fields can have dots in their names.
Because there are though two ways to create the same field with the introduction
of the ability to emit multiple fields, we have to make sure that a runtime field with
a certain name cannot be defined twice, which is why the following mappings are
rejected with the error `Found two runtime fields with same name [log.response]`:

```
PUT localhost:9200/logs/_mappings
{
    "runtime" : {
        "log.response" : {
            "type" : "keyword"
        },
        "log" : {
            "type" : "composite",
            "script" : "emit(\"response\", grok(\"%{COMMONAPACHELOG}\").extract(doc[\"message.keyword\"].value)?.response)",
            "fields" : {
                "response" : {
                    "type" : "long"
                }
            }
        }
    }
}
```

Closes #68203
---
 .../action/PainlessExecuteAction.java         |  11 +-
 ...g.elasticsearch.script.composite_field.txt |  21 +
 .../action/PainlessExecuteApiTests.java       |  14 +
 .../test/runtime_fields/110_composite.yml     | 104 +++++
 .../index/mapper/AbstractScriptFieldType.java |  44 +-
 .../index/mapper/BooleanScriptFieldType.java  |  15 +-
 .../index/mapper/CompositeRuntimeField.java   | 134 ++++++
 .../index/mapper/DateScriptFieldType.java     |  18 +-
 .../index/mapper/DoubleScriptFieldType.java   |  14 +-
 .../index/mapper/DynamicFieldsBuilder.java    |   4 +-
 .../index/mapper/FieldMapper.java             |   2 +-
 .../index/mapper/GeoPointScriptFieldType.java |  15 +-
 .../index/mapper/IpScriptFieldType.java       |  14 +-
 .../index/mapper/KeywordScriptFieldType.java  |  14 +-
 .../index/mapper/LeafRuntimeField.java        |  15 +-
 .../index/mapper/LongScriptFieldType.java     |  14 +-
 .../index/mapper/MappingLookup.java           |   4 +-
 .../index/mapper/RootObjectMapper.java        |   7 +-
 .../index/mapper/RuntimeField.java            |  61 ++-
 .../index/query/SearchExecutionContext.java   |   8 +-
 .../elasticsearch/indices/IndicesModule.java  |  16 +-
 .../script/AbstractFieldScript.java           |  12 +-
 .../script/BooleanFieldScript.java            |  21 +
 .../script/CompositeFieldScript.java          | 116 +++++
 .../elasticsearch/script/DateFieldScript.java |  21 +
 .../script/DoubleFieldScript.java             |  21 +
 .../script/GeoPointFieldScript.java           |  21 +
 .../elasticsearch/script/IpFieldScript.java   |  21 +
 .../elasticsearch/script/LongFieldScript.java |  21 +
 .../elasticsearch/script/ScriptModule.java    |  11 +-
 .../script/StringFieldScript.java             |  21 +
 .../mapper/CompositeRuntimeFieldTests.java    | 438 ++++++++++++++++++
 .../index/mapper/DocumentParserTests.java     |  16 +-
 .../index/mapper/TestRuntimeField.java        |   5 +-
 .../script/MockScriptEngine.java              |   9 +
 35 files changed, 1237 insertions(+), 66 deletions(-)
 create mode 100644 modules/lang-painless/src/main/resources/org/elasticsearch/painless/org.elasticsearch.script.composite_field.txt
 create mode 100644 modules/runtime-fields-common/src/yamlRestTest/resources/rest-api-spec/test/runtime_fields/110_composite.yml
 create mode 100644 server/src/main/java/org/elasticsearch/index/mapper/CompositeRuntimeField.java
 create mode 100644 server/src/main/java/org/elasticsearch/script/CompositeFieldScript.java
 create mode 100644 server/src/test/java/org/elasticsearch/index/mapper/CompositeRuntimeFieldTests.java

diff --git a/modules/lang-painless/src/main/java/org/elasticsearch/painless/action/PainlessExecuteAction.java b/modules/lang-painless/src/main/java/org/elasticsearch/painless/action/PainlessExecuteAction.java
index 7b72b8cab142..6899d58b17cf 100644
--- a/modules/lang-painless/src/main/java/org/elasticsearch/painless/action/PainlessExecuteAction.java
+++ b/modules/lang-painless/src/main/java/org/elasticsearch/painless/action/PainlessExecuteAction.java
@@ -68,6 +68,7 @@ import org.elasticsearch.rest.BaseRestHandler;
 import org.elasticsearch.rest.RestRequest;
 import org.elasticsearch.rest.action.RestToXContentListener;
 import org.elasticsearch.script.BooleanFieldScript;
+import org.elasticsearch.script.CompositeFieldScript;
 import org.elasticsearch.script.DateFieldScript;
 import org.elasticsearch.script.DocValuesDocReader;
 import org.elasticsearch.script.DoubleFieldScript;
@@ -624,12 +625,20 @@ public class PainlessExecuteAction extends ActionType<PainlessExecuteAction.Resp
                 return prepareRamIndex(request, (context, leafReaderContext) -> {
                     StringFieldScript.Factory factory = scriptService.compile(request.script, StringFieldScript.CONTEXT);
                     StringFieldScript.LeafFactory leafFactory =
-                            factory.newFactory(StringFieldScript.CONTEXT.name, request.getScript().getParams(), context.lookup());
+                        factory.newFactory(StringFieldScript.CONTEXT.name, request.getScript().getParams(), context.lookup());
                     StringFieldScript stringFieldScript = leafFactory.newInstance(leafReaderContext);
                     List<String> keywords = new ArrayList<>();
                     stringFieldScript.runForDoc(0, keywords::add);
                     return new Response(keywords);
                 }, indexService);
+            } else if (scriptContext == CompositeFieldScript.CONTEXT) {
+                return prepareRamIndex(request, (context, leafReaderContext) -> {
+                    CompositeFieldScript.Factory factory = scriptService.compile(request.script, CompositeFieldScript.CONTEXT);
+                    CompositeFieldScript.LeafFactory leafFactory =
+                        factory.newFactory(CompositeFieldScript.CONTEXT.name, request.getScript().getParams(), context.lookup());
+                    CompositeFieldScript compositeFieldScript = leafFactory.newInstance(leafReaderContext);
+                    return new Response(compositeFieldScript.runForDoc(0));
+                }, indexService);
             } else {
                 throw new UnsupportedOperationException("unsupported context [" + scriptContext.name + "]");
             }
diff --git a/modules/lang-painless/src/main/resources/org/elasticsearch/painless/org.elasticsearch.script.composite_field.txt b/modules/lang-painless/src/main/resources/org/elasticsearch/painless/org.elasticsearch.script.composite_field.txt
new file mode 100644
index 000000000000..b5c499abb877
--- /dev/null
+++ b/modules/lang-painless/src/main/resources/org/elasticsearch/painless/org.elasticsearch.script.composite_field.txt
@@ -0,0 +1,21 @@
+#
+# Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+# or more contributor license agreements. Licensed under the Elastic License
+# 2.0 and the Server Side Public License, v 1; you may not use this file except
+# in compliance with, at your election, the Elastic License 2.0 or the Server
+# Side Public License, v 1.
+#
+
+# The whitelist for composite runtime fields
+
+# These two whitelists are required for painless to find the classes
+class org.elasticsearch.script.CompositeFieldScript @no_import {
+}
+class org.elasticsearch.script.CompositeFieldScript$Factory @no_import {
+}
+
+static_import {
+    # The `emit` callback to collect values for the fields
+    void emit(org.elasticsearch.script.CompositeFieldScript, String, Object) bound_to org.elasticsearch.script.CompositeFieldScript$EmitField
+    void emit(org.elasticsearch.script.CompositeFieldScript, Map) bound_to org.elasticsearch.script.CompositeFieldScript$EmitMap
+}
diff --git a/modules/lang-painless/src/test/java/org/elasticsearch/painless/action/PainlessExecuteApiTests.java b/modules/lang-painless/src/test/java/org/elasticsearch/painless/action/PainlessExecuteApiTests.java
index a91cd4858dff..1ea75f511a1d 100644
--- a/modules/lang-painless/src/test/java/org/elasticsearch/painless/action/PainlessExecuteApiTests.java
+++ b/modules/lang-painless/src/test/java/org/elasticsearch/painless/action/PainlessExecuteApiTests.java
@@ -288,6 +288,20 @@ public class PainlessExecuteApiTests extends ESSingleNodeTestCase {
         assertEquals(Arrays.asList("test", "baz was not here", "Data", "-10", "20", "9"), response.getResult());
     }
 
+    public void testCompositeExecutionContext() throws IOException {
+        ScriptService scriptService = getInstanceFromNode(ScriptService.class);
+        IndexService indexService = createIndex("index", Settings.EMPTY, "doc", "rank", "type=long", "text", "type=keyword");
+
+        Request.ContextSetup contextSetup = new Request.ContextSetup("index", new BytesArray("{}"), new MatchAllQueryBuilder());
+        contextSetup.setXContentType(XContentType.JSON);
+        Request request = new Request(new Script(ScriptType.INLINE, "painless",
+            "emit(\"foo\", \"bar\"); emit(\"foo2\", 2);", emptyMap()), "composite_field", contextSetup);
+        Response response = innerShardOperation(request, scriptService, indexService);
+        assertEquals(Map.of(
+            "composite_field.foo", List.of("bar"),
+            "composite_field.foo2", List.of(2)), response.getResult());
+    }
+
     public void testContextWhitelists() throws IOException {
         ScriptService scriptService = getInstanceFromNode(ScriptService.class);
         // score
diff --git a/modules/runtime-fields-common/src/yamlRestTest/resources/rest-api-spec/test/runtime_fields/110_composite.yml b/modules/runtime-fields-common/src/yamlRestTest/resources/rest-api-spec/test/runtime_fields/110_composite.yml
new file mode 100644
index 000000000000..2c80545050bd
--- /dev/null
+++ b/modules/runtime-fields-common/src/yamlRestTest/resources/rest-api-spec/test/runtime_fields/110_composite.yml
@@ -0,0 +1,104 @@
+---
+setup:
+  - do:
+      indices.create:
+        index: http_logs
+        body:
+          settings:
+            number_of_shards: 1
+            number_of_replicas: 0
+          mappings:
+            runtime:
+              http:
+                type: composite
+                script:
+                  source: |
+                    emit(grok('%{COMMONAPACHELOG}').extract(doc["message"].value));
+                fields:
+                  clientip:
+                    type: ip
+                  verb:
+                    type: keyword
+                  response:
+                    type: long
+            properties:
+              timestamp:
+                type: date
+              message:
+                type: keyword
+  - do:
+      bulk:
+        index: http_logs
+        refresh: true
+        body: |
+          {"index":{}}
+          {"timestamp": "1998-04-30T14:30:17-05:00", "message" : "40.135.0.0 - - [30/Apr/1998:14:30:17 -0500] \"GET /images/hm_bg.jpg HTTP/1.0\" 200 24736"}
+          {"index":{}}
+          {"timestamp": "1998-04-30T14:30:53-05:00", "message" : "232.0.0.0 - - [30/Apr/1998:14:30:53 -0500] \"GET /images/hm_bg.jpg HTTP/1.0\" 200 24736"}
+          {"index":{}}
+          {"timestamp": "1998-04-30T14:31:12-05:00", "message" : "26.1.0.0 - - [30/Apr/1998:14:31:12 -0500] \"GET /images/hm_bg.jpg HTTP/1.0\" 200 24736"}
+          {"index":{}}
+          {"timestamp": "1998-04-30T14:31:19-05:00", "message" : "247.37.0.0 - - [30/Apr/1998:14:31:19 -0500] \"GET /french/splash_inet.html HTTP/1.0\" 200 3781"}
+          {"index":{}}
+          {"timestamp": "1998-04-30T14:31:22-05:00", "message" : "247.37.0.0 - - [30/Apr/1998:14:31:22 -0500] \"GET /images/hm_nbg.jpg HTTP/1.0\" 304 0"}
+          {"index":{}}
+          {"timestamp": "1998-04-30T14:31:27-05:00", "message" : "252.0.0.0 - - [30/Apr/1998:14:31:27 -0500] \"GET /images/hm_bg.jpg HTTP/1.0\" 200 24736"}
+          {"index":{}}
+          {"timestamp": "1998-04-30T14:31:28-05:00", "message" : "not a valid apache log"}
+
+---
+fetch:
+  - do:
+      search:
+        index: http_logs
+        body:
+          sort: timestamp
+          fields:
+            - http.clientip
+            - http.verb
+            - http.response
+  - match: {hits.total.value: 7}
+  - match: {hits.hits.0.fields.http\.clientip: [40.135.0.0] }
+  - match: {hits.hits.0.fields.http\.verb: [GET] }
+  - match: {hits.hits.0.fields.http\.response: [200] }
+  - is_false: hits.hits.6.fields.http\.clientip
+  - is_false: hits.hits.6.fields.http\.verb
+  - is_false: hits.hits.6.fields.http\.response
+
+---
+query:
+  - do:
+      search:
+        index: http_logs
+        body:
+          query:
+            term:
+              http.verb: GET
+  - match: { hits.total.value: 6 }
+
+  - do:
+      search:
+        index: http_logs
+        body:
+          query:
+            range:
+              http.clientip:
+                from: 232.0.0.0
+                to: 253.0.0.0
+  - match: { hits.total.value: 4 }
+
+---
+"terms agg":
+  - do:
+      search:
+        index: http_logs
+        body:
+          aggs:
+            response:
+              terms:
+                field: http.response
+  - match: {hits.total.value: 7}
+  - match: {aggregations.response.buckets.0.key: 200 }
+  - match: {aggregations.response.buckets.0.doc_count: 5 }
+  - match: {aggregations.response.buckets.1.key: 304 }
+  - match: {aggregations.response.buckets.1.doc_count: 1 }
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/AbstractScriptFieldType.java b/server/src/main/java/org/elasticsearch/index/mapper/AbstractScriptFieldType.java
index 4bd34abceb59..35146ebca63e 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/AbstractScriptFieldType.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/AbstractScriptFieldType.java
@@ -18,9 +18,9 @@ import org.elasticsearch.common.geo.ShapeRelation;
 import org.elasticsearch.common.time.DateMathParser;
 import org.elasticsearch.common.unit.Fuzziness;
 import org.elasticsearch.index.query.SearchExecutionContext;
+import org.elasticsearch.script.CompositeFieldScript;
 import org.elasticsearch.script.Script;
 import org.elasticsearch.script.ScriptContext;
-import org.elasticsearch.script.ScriptType;
 import org.elasticsearch.search.lookup.SearchLookup;
 
 import java.time.ZoneId;
@@ -194,31 +194,49 @@ abstract class AbstractScriptFieldType<LeafFactory> extends MappedFieldType {
 
     abstract static class Builder<Factory> extends RuntimeField.Builder {
         private final ScriptContext<Factory> scriptContext;
-        private final Factory parseFromSourceFactory;
 
         final FieldMapper.Parameter<Script> script = new FieldMapper.Parameter<>(
             "script",
             true,
             () -> null,
-            Builder::parseScript,
-            initializerNotSupported()
+            RuntimeField::parseScript,
+            RuntimeField.initializerNotSupported()
         ).setSerializerCheck((id, ic, v) -> ic);
 
-        Builder(String name, ScriptContext<Factory> scriptContext, Factory parseFromSourceFactory) {
+        Builder(String name, ScriptContext<Factory> scriptContext) {
             super(name);
             this.scriptContext = scriptContext;
-            this.parseFromSourceFactory = parseFromSourceFactory;
         }
 
+        abstract Factory getParseFromSourceFactory();
+
+        abstract Factory getCompositeLeafFactory(Function<SearchLookup, CompositeFieldScript.LeafFactory> parentScriptFactory);
+
         @Override
         protected final RuntimeField createRuntimeField(MappingParserContext parserContext) {
             if (script.get() == null) {
-                return createRuntimeField(parseFromSourceFactory);
+                return createRuntimeField(getParseFromSourceFactory());
             }
             Factory factory = parserContext.scriptCompiler().compile(script.getValue(), scriptContext);
             return createRuntimeField(factory);
         }
 
+        @Override
+        protected final RuntimeField createChildRuntimeField(MappingParserContext parserContext,
+                                                        String parent,
+                                                        Function<SearchLookup, CompositeFieldScript.LeafFactory> parentScriptFactory) {
+            if (script.isConfigured()) {
+                throw new IllegalArgumentException("Cannot use [script] parameter on sub-field [" + name +
+                    "] of composite field [" + parent + "]");
+            }
+            String fullName = parent + "." + name;
+            return new LeafRuntimeField(
+                name,
+                createFieldType(fullName, getCompositeLeafFactory(parentScriptFactory), getScript(), meta()),
+                getParameters()
+            );
+        }
+
         final RuntimeField createRuntimeField(Factory scriptFactory) {
             AbstractScriptFieldType<?> fieldType = createFieldType(name, scriptFactory, getScript(), meta());
             return new LeafRuntimeField(name, fieldType, getParameters());
@@ -239,17 +257,5 @@ abstract class AbstractScriptFieldType<LeafFactory> extends MappedFieldType {
             }
             return script.get();
         }
-
-        private static Script parseScript(String name, MappingParserContext parserContext, Object scriptObject) {
-            Script script = Script.parse(scriptObject);
-            if (script.getType() == ScriptType.STORED) {
-                throw new IllegalArgumentException("stored scripts are not supported for runtime field [" + name + "]");
-            }
-            return script;
-        }
-    }
-
-    static <T> Function<FieldMapper, T> initializerNotSupported() {
-        return mapper -> { throw new UnsupportedOperationException(); };
     }
 }
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/BooleanScriptFieldType.java b/server/src/main/java/org/elasticsearch/index/mapper/BooleanScriptFieldType.java
index 51e2cffd78c5..8d26a2b38207 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/BooleanScriptFieldType.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/BooleanScriptFieldType.java
@@ -18,6 +18,7 @@ import org.elasticsearch.core.Booleans;
 import org.elasticsearch.index.fielddata.BooleanScriptFieldData;
 import org.elasticsearch.index.query.SearchExecutionContext;
 import org.elasticsearch.script.BooleanFieldScript;
+import org.elasticsearch.script.CompositeFieldScript;
 import org.elasticsearch.script.Script;
 import org.elasticsearch.search.DocValueFormat;
 import org.elasticsearch.search.lookup.SearchLookup;
@@ -27,6 +28,7 @@ import org.elasticsearch.search.runtime.BooleanScriptFieldTermQuery;
 import java.time.ZoneId;
 import java.util.Collection;
 import java.util.Map;
+import java.util.function.Function;
 import java.util.function.Supplier;
 
 public final class BooleanScriptFieldType extends AbstractScriptFieldType<BooleanFieldScript.LeafFactory> {
@@ -35,7 +37,7 @@ public final class BooleanScriptFieldType extends AbstractScriptFieldType<Boolea
 
     private static class Builder extends AbstractScriptFieldType.Builder<BooleanFieldScript.Factory> {
         Builder(String name) {
-            super(name, BooleanFieldScript.CONTEXT, BooleanFieldScript.PARSE_FROM_SOURCE);
+            super(name, BooleanFieldScript.CONTEXT);
         }
 
         @Override
@@ -45,6 +47,17 @@ public final class BooleanScriptFieldType extends AbstractScriptFieldType<Boolea
                                                    Map<String, String> meta) {
             return new BooleanScriptFieldType(name, factory, script, meta);
         }
+
+        @Override
+        BooleanFieldScript.Factory getParseFromSourceFactory() {
+            return BooleanFieldScript.PARSE_FROM_SOURCE;
+        }
+
+        @Override
+        BooleanFieldScript.Factory getCompositeLeafFactory(Function<SearchLookup, CompositeFieldScript.LeafFactory> parentScriptFactory) {
+            return BooleanFieldScript.leafAdapter(parentScriptFactory);
+        }
+
     }
 
     public static RuntimeField sourceOnly(String name) {
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/CompositeRuntimeField.java b/server/src/main/java/org/elasticsearch/index/mapper/CompositeRuntimeField.java
new file mode 100644
index 000000000000..c841eef7768c
--- /dev/null
+++ b/server/src/main/java/org/elasticsearch/index/mapper/CompositeRuntimeField.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.index.mapper;
+
+import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.script.CompositeFieldScript;
+import org.elasticsearch.script.Script;
+import org.elasticsearch.search.lookup.SearchLookup;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+/**
+ * A runtime field of type object. Defines a script at the top level, which emits multiple sub-fields.
+ * The sub-fields are declared within the object in order to be made available to the field_caps and search API.
+ */
+public class CompositeRuntimeField implements RuntimeField {
+
+    public static final String CONTENT_TYPE = "composite";
+
+    public static final Parser PARSER = new Parser(name ->
+        new RuntimeField.Builder(name) {
+            private final FieldMapper.Parameter<Script> script = new FieldMapper.Parameter<>(
+                "script",
+                false,
+                () -> null,
+                RuntimeField::parseScript,
+                RuntimeField.initializerNotSupported()
+            ).setValidator(s -> {
+                if (s == null) {
+                    throw new IllegalArgumentException("composite runtime field [" + name + "] must declare a [script]");
+                }
+            });
+
+            private final FieldMapper.Parameter<Map<String, Object>> fields = new FieldMapper.Parameter<Map<String, Object>>(
+                "fields",
+                false,
+                Collections::emptyMap,
+                (f, p, o) -> parseFields(f, o),
+                RuntimeField.initializerNotSupported()
+            ).setValidator(objectMap -> {
+                if (objectMap == null || objectMap.isEmpty()) {
+                    throw new IllegalArgumentException("composite runtime field [" + name + "] must declare its [fields]");
+                }
+            });
+
+            @Override
+            protected List<FieldMapper.Parameter<?>> getParameters() {
+                List<FieldMapper.Parameter<?>> parameters = new ArrayList<>(super.getParameters());
+                parameters.add(script);
+                parameters.add(fields);
+                return Collections.unmodifiableList(parameters);
+            }
+
+            @Override
+            protected RuntimeField createChildRuntimeField(MappingParserContext parserContext,
+                                                      String parent,
+                                                      Function<SearchLookup, CompositeFieldScript.LeafFactory> parentScriptFactory) {
+                throw new IllegalArgumentException("Composite field [" + name + "] cannot be a child of composite field [" + parent + "]");
+            }
+
+            @Override
+            protected RuntimeField createRuntimeField(MappingParserContext parserContext) {
+                CompositeFieldScript.Factory factory = parserContext.scriptCompiler().compile(script.get(), CompositeFieldScript.CONTEXT);
+                Function<RuntimeField.Builder, RuntimeField> builder = b -> b.createChildRuntimeField(
+                    parserContext,
+                    name,
+                    lookup -> factory.newFactory(name, script.get().getParams(), lookup)
+                );
+                Map<String, RuntimeField> runtimeFields
+                    = RuntimeField.parseRuntimeFields(fields.getValue(), parserContext, builder, false);
+                return new CompositeRuntimeField(name, getParameters(), runtimeFields.values());
+            }
+        });
+
+    private final String name;
+    private final List<FieldMapper.Parameter<?>> parameters;
+    private final Collection<RuntimeField> subfields;
+
+    CompositeRuntimeField(String name, List<FieldMapper.Parameter<?>> parameters, Collection<RuntimeField> subfields) {
+        this.name = name;
+        this.parameters = parameters;
+        this.subfields = subfields;
+    }
+
+    @Override
+    public String name() {
+        return name;
+    }
+
+    @Override
+    public Stream<MappedFieldType> asMappedFieldTypes() {
+        return subfields.stream().flatMap(RuntimeField::asMappedFieldTypes);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(name);
+        builder.field("type", "composite");
+        boolean includeDefaults = params.paramAsBoolean("include_defaults", false);
+        for (FieldMapper.Parameter<?> parameter : parameters) {
+            parameter.toXContent(builder, includeDefaults);
+        }
+        builder.startObject("fields");
+        for (RuntimeField subfield : subfields) {
+            subfield.toXContent(builder, params);
+        }
+        builder.endObject();
+        builder.endObject();
+        return builder;
+    }
+
+    private static Map<String, Object> parseFields(String name, Object fieldsObject) {
+        if (fieldsObject instanceof Map == false) {
+            throw new MapperParsingException("[fields] must be an object, got " + fieldsObject.getClass().getSimpleName() +
+                "[" + fieldsObject + "] for field [" + name +"]");
+        }
+        @SuppressWarnings("unchecked")
+        Map<String, Object> fields = (Map<String, Object>) fieldsObject;
+        return fields;
+    }
+}
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/DateScriptFieldType.java b/server/src/main/java/org/elasticsearch/index/mapper/DateScriptFieldType.java
index 55a1fcd4175a..15cf62882deb 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/DateScriptFieldType.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/DateScriptFieldType.java
@@ -23,6 +23,7 @@ import org.elasticsearch.index.mapper.DateFieldMapper.DateFieldType;
 import org.elasticsearch.index.mapper.DateFieldMapper.Resolution;
 import org.elasticsearch.index.query.SearchExecutionContext;
 import org.elasticsearch.script.DateFieldScript;
+import org.elasticsearch.script.CompositeFieldScript;
 import org.elasticsearch.script.Script;
 import org.elasticsearch.search.DocValueFormat;
 import org.elasticsearch.search.lookup.SearchLookup;
@@ -40,6 +41,7 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.function.Function;
 import java.util.function.Supplier;
 
 public class DateScriptFieldType extends AbstractScriptFieldType<DateFieldScript.LeafFactory> {
@@ -50,7 +52,7 @@ public class DateScriptFieldType extends AbstractScriptFieldType<DateFieldScript
         private final FieldMapper.Parameter<String> format = FieldMapper.Parameter.stringParam(
             "format",
             true,
-            initializerNotSupported(),
+            RuntimeField.initializerNotSupported(),
             null
         ).setSerializer((b, n, v) -> {
             if (v != null && false == v.equals(DateFieldMapper.DEFAULT_DATE_TIME_FORMATTER.pattern())) {
@@ -63,7 +65,7 @@ public class DateScriptFieldType extends AbstractScriptFieldType<DateFieldScript
             true,
             () -> null,
             (n, c, o) -> o == null ? null : LocaleUtils.parse(o.toString()),
-            initializerNotSupported()
+            RuntimeField.initializerNotSupported()
         ).setSerializer((b, n, v) -> {
             if (v != null && false == v.equals(Locale.ROOT)) {
                 b.field(n, v.toString());
@@ -71,7 +73,7 @@ public class DateScriptFieldType extends AbstractScriptFieldType<DateFieldScript
         }, Object::toString).acceptsNull();
 
         Builder(String name) {
-            super(name, DateFieldScript.CONTEXT, DateFieldScript.PARSE_FROM_SOURCE);
+            super(name, DateFieldScript.CONTEXT);
         }
 
         @Override
@@ -89,6 +91,16 @@ public class DateScriptFieldType extends AbstractScriptFieldType<DateFieldScript
             DateFormatter dateTimeFormatter = DateFormatter.forPattern(pattern).withLocale(locale);
             return new DateScriptFieldType(name, factory, dateTimeFormatter, script, meta);
         }
+
+        @Override
+        DateFieldScript.Factory getParseFromSourceFactory() {
+            return DateFieldScript.PARSE_FROM_SOURCE;
+        }
+
+        @Override
+        DateFieldScript.Factory getCompositeLeafFactory(Function<SearchLookup, CompositeFieldScript.LeafFactory> parentScriptFactory) {
+            return DateFieldScript.leafAdapter(parentScriptFactory);
+        }
     }
 
     public static RuntimeField sourceOnly(String name, DateFormatter dateTimeFormatter) {
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/DoubleScriptFieldType.java b/server/src/main/java/org/elasticsearch/index/mapper/DoubleScriptFieldType.java
index ded001311046..af9ca71d1deb 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/DoubleScriptFieldType.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/DoubleScriptFieldType.java
@@ -18,6 +18,7 @@ import org.elasticsearch.index.fielddata.DoubleScriptFieldData;
 import org.elasticsearch.index.mapper.NumberFieldMapper.NumberType;
 import org.elasticsearch.index.query.SearchExecutionContext;
 import org.elasticsearch.script.DoubleFieldScript;
+import org.elasticsearch.script.CompositeFieldScript;
 import org.elasticsearch.script.Script;
 import org.elasticsearch.search.DocValueFormat;
 import org.elasticsearch.search.lookup.SearchLookup;
@@ -29,6 +30,7 @@ import org.elasticsearch.search.runtime.DoubleScriptFieldTermsQuery;
 import java.time.ZoneId;
 import java.util.Collection;
 import java.util.Map;
+import java.util.function.Function;
 import java.util.function.Supplier;
 
 public final class DoubleScriptFieldType extends AbstractScriptFieldType<DoubleFieldScript.LeafFactory> {
@@ -37,7 +39,7 @@ public final class DoubleScriptFieldType extends AbstractScriptFieldType<DoubleF
 
     private static class Builder extends AbstractScriptFieldType.Builder<DoubleFieldScript.Factory> {
         Builder(String name) {
-            super(name, DoubleFieldScript.CONTEXT, DoubleFieldScript.PARSE_FROM_SOURCE);
+            super(name, DoubleFieldScript.CONTEXT);
         }
 
         @Override
@@ -47,6 +49,16 @@ public final class DoubleScriptFieldType extends AbstractScriptFieldType<DoubleF
                                                    Map<String, String> meta) {
             return new DoubleScriptFieldType(name, factory, script, meta);
         }
+
+        @Override
+        DoubleFieldScript.Factory getParseFromSourceFactory() {
+            return DoubleFieldScript.PARSE_FROM_SOURCE;
+        }
+
+        @Override
+        DoubleFieldScript.Factory getCompositeLeafFactory(Function<SearchLookup, CompositeFieldScript.LeafFactory> parentScriptFactory) {
+            return DoubleFieldScript.leafAdapter(parentScriptFactory);
+        }
     }
 
     public static RuntimeField sourceOnly(String name) {
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/DynamicFieldsBuilder.java b/server/src/main/java/org/elasticsearch/index/mapper/DynamicFieldsBuilder.java
index 247f0819a6c9..d98cdb403f84 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/DynamicFieldsBuilder.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/DynamicFieldsBuilder.java
@@ -196,8 +196,8 @@ final class DynamicFieldsBuilder {
             if (parser == null) {
                 throw new MapperParsingException("failed to find type parsed [" + mappingType + "] for [" + fullName + "]");
             }
-            RuntimeField runtimeField = parser.parse(fullName, mapping, parserContext);
-            Runtime.createDynamicField(runtimeField, context);
+            RuntimeField.Builder builder = parser.parse(fullName, mapping, parserContext);
+            Runtime.createDynamicField(builder.createRuntimeField(parserContext), context);
         } else {
             Mapper.Builder builder = parseDynamicTemplateMapping(name, mappingType, mapping, dateFormatter, context);
             CONCRETE.createDynamicField(builder, context);
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/FieldMapper.java b/server/src/main/java/org/elasticsearch/index/mapper/FieldMapper.java
index 694aad363c70..57d42c43d0c7 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/FieldMapper.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/FieldMapper.java
@@ -740,7 +740,7 @@ public abstract class FieldMapper extends Mapper implements Cloneable {
             return this;
         }
 
-        private void validate() {
+        void validate() {
             if (validator != null) {
                 validator.accept(getValue());
             }
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/GeoPointScriptFieldType.java b/server/src/main/java/org/elasticsearch/index/mapper/GeoPointScriptFieldType.java
index 81fe0731730c..d5547dfdded7 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/GeoPointScriptFieldType.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/GeoPointScriptFieldType.java
@@ -22,6 +22,7 @@ import org.elasticsearch.geometry.Geometry;
 import org.elasticsearch.index.fielddata.GeoPointScriptFieldData;
 import org.elasticsearch.index.query.SearchExecutionContext;
 import org.elasticsearch.script.GeoPointFieldScript;
+import org.elasticsearch.script.CompositeFieldScript;
 import org.elasticsearch.script.Script;
 import org.elasticsearch.search.lookup.SearchLookup;
 import org.elasticsearch.search.runtime.GeoPointScriptFieldDistanceFeatureQuery;
@@ -31,12 +32,13 @@ import org.elasticsearch.search.runtime.GeoPointScriptFieldGeoShapeQuery;
 import java.time.ZoneId;
 import java.util.Arrays;
 import java.util.Map;
+import java.util.function.Function;
 import java.util.function.Supplier;
 
 public final class GeoPointScriptFieldType extends AbstractScriptFieldType<GeoPointFieldScript.LeafFactory> implements GeoShapeQueryable {
 
     public static final RuntimeField.Parser PARSER = new RuntimeField.Parser(name ->
-        new Builder<>(name, GeoPointFieldScript.CONTEXT, GeoPointFieldScript.PARSE_FROM_SOURCE) {
+        new Builder<>(name, GeoPointFieldScript.CONTEXT) {
             @Override
             AbstractScriptFieldType<?> createFieldType(String name,
                                                        GeoPointFieldScript.Factory factory,
@@ -44,6 +46,17 @@ public final class GeoPointScriptFieldType extends AbstractScriptFieldType<GeoPo
                                                        Map<String, String> meta) {
                 return new GeoPointScriptFieldType(name, factory, getScript(), meta());
             }
+
+            @Override
+            GeoPointFieldScript.Factory getParseFromSourceFactory() {
+                return GeoPointFieldScript.PARSE_FROM_SOURCE;
+            }
+
+            @Override
+            GeoPointFieldScript.Factory getCompositeLeafFactory(
+                Function<SearchLookup, CompositeFieldScript.LeafFactory> parentScriptFactory) {
+                return GeoPointFieldScript.leafAdapter(parentScriptFactory);
+            }
         });
 
     GeoPointScriptFieldType(
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/IpScriptFieldType.java b/server/src/main/java/org/elasticsearch/index/mapper/IpScriptFieldType.java
index aedc55399539..1f81b690a857 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/IpScriptFieldType.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/IpScriptFieldType.java
@@ -22,6 +22,7 @@ import org.elasticsearch.core.Tuple;
 import org.elasticsearch.index.fielddata.IpScriptFieldData;
 import org.elasticsearch.index.query.SearchExecutionContext;
 import org.elasticsearch.script.IpFieldScript;
+import org.elasticsearch.script.CompositeFieldScript;
 import org.elasticsearch.script.Script;
 import org.elasticsearch.search.DocValueFormat;
 import org.elasticsearch.search.lookup.SearchLookup;
@@ -37,12 +38,13 @@ import java.util.Collection;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.function.Function;
 import java.util.function.Supplier;
 
 public final class IpScriptFieldType extends AbstractScriptFieldType<IpFieldScript.LeafFactory> {
 
     public static final RuntimeField.Parser PARSER = new RuntimeField.Parser(name ->
-        new Builder<>(name, IpFieldScript.CONTEXT, IpFieldScript.PARSE_FROM_SOURCE) {
+        new Builder<>(name, IpFieldScript.CONTEXT) {
             @Override
             AbstractScriptFieldType<?> createFieldType(String name,
                                                        IpFieldScript.Factory factory,
@@ -50,6 +52,16 @@ public final class IpScriptFieldType extends AbstractScriptFieldType<IpFieldScri
                                                        Map<String, String> meta) {
                 return new IpScriptFieldType(name, factory, getScript(), meta());
             }
+
+            @Override
+            IpFieldScript.Factory getParseFromSourceFactory() {
+                return IpFieldScript.PARSE_FROM_SOURCE;
+            }
+
+            @Override
+            IpFieldScript.Factory getCompositeLeafFactory(Function<SearchLookup, CompositeFieldScript.LeafFactory> parentScriptFactory) {
+                return IpFieldScript.leafAdapter(parentScriptFactory);
+            }
         });
 
     IpScriptFieldType(
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/KeywordScriptFieldType.java b/server/src/main/java/org/elasticsearch/index/mapper/KeywordScriptFieldType.java
index 6ebecbb45ded..edcb1f5cae38 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/KeywordScriptFieldType.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/KeywordScriptFieldType.java
@@ -16,6 +16,7 @@ import org.elasticsearch.common.time.DateMathParser;
 import org.elasticsearch.common.unit.Fuzziness;
 import org.elasticsearch.index.fielddata.StringScriptFieldData;
 import org.elasticsearch.index.query.SearchExecutionContext;
+import org.elasticsearch.script.CompositeFieldScript;
 import org.elasticsearch.script.Script;
 import org.elasticsearch.script.StringFieldScript;
 import org.elasticsearch.search.lookup.SearchLookup;
@@ -33,6 +34,7 @@ import java.util.Collection;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
+import java.util.function.Function;
 import java.util.function.Supplier;
 
 import static java.util.stream.Collectors.toSet;
@@ -43,7 +45,7 @@ public final class KeywordScriptFieldType extends AbstractScriptFieldType<String
 
     private static class Builder extends AbstractScriptFieldType.Builder<StringFieldScript.Factory> {
         Builder(String name) {
-            super(name, StringFieldScript.CONTEXT, StringFieldScript.PARSE_FROM_SOURCE);
+            super(name, StringFieldScript.CONTEXT);
         }
 
         @Override
@@ -53,6 +55,16 @@ public final class KeywordScriptFieldType extends AbstractScriptFieldType<String
                                                    Map<String, String> meta) {
             return new KeywordScriptFieldType(name, factory, script, meta);
         }
+
+        @Override
+        StringFieldScript.Factory getParseFromSourceFactory() {
+            return StringFieldScript.PARSE_FROM_SOURCE;
+        }
+
+        @Override
+        StringFieldScript.Factory getCompositeLeafFactory(Function<SearchLookup, CompositeFieldScript.LeafFactory> parentScriptFactory) {
+            return StringFieldScript.leafAdapter(parentScriptFactory);
+        }
     }
 
     public static RuntimeField sourceOnly(String name) {
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/LeafRuntimeField.java b/server/src/main/java/org/elasticsearch/index/mapper/LeafRuntimeField.java
index 8797fc52a475..166aec60f45b 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/LeafRuntimeField.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/LeafRuntimeField.java
@@ -11,13 +11,12 @@ package org.elasticsearch.index.mapper;
 import org.elasticsearch.common.xcontent.XContentBuilder;
 
 import java.io.IOException;
-import java.util.Collection;
-import java.util.Collections;
 import java.util.List;
+import java.util.stream.Stream;
 
 /**
- * RuntimeField base class for leaf fields that will only ever return
- * a single MappedFieldType from {@link RuntimeField#asMappedFieldTypes()}
+ * RuntimeField base class for leaf fields that will only ever return a single {@link MappedFieldType}
+ * from {@link RuntimeField#asMappedFieldTypes()}. Can be a standalone runtime field, or part of a composite.
  */
 public final class LeafRuntimeField implements RuntimeField {
     private final String name;
@@ -28,17 +27,17 @@ public final class LeafRuntimeField implements RuntimeField {
         this.name = name;
         this.mappedFieldType = mappedFieldType;
         this.parameters = parameters;
-        assert name.equals(mappedFieldType.name());
+        assert mappedFieldType.name().endsWith(name) : "full name: " + mappedFieldType.name() + " - leaf name: " + name;
     }
 
     @Override
     public String name() {
-        return name;
+        return mappedFieldType.name();
     }
 
     @Override
-    public Collection<MappedFieldType> asMappedFieldTypes() {
-        return Collections.singleton(mappedFieldType);
+    public Stream<MappedFieldType> asMappedFieldTypes() {
+        return Stream.of(mappedFieldType);
     }
 
     @Override
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/LongScriptFieldType.java b/server/src/main/java/org/elasticsearch/index/mapper/LongScriptFieldType.java
index cee1a9bd695d..ecd50a3477dc 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/LongScriptFieldType.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/LongScriptFieldType.java
@@ -18,6 +18,7 @@ import org.elasticsearch.index.fielddata.LongScriptFieldData;
 import org.elasticsearch.index.mapper.NumberFieldMapper.NumberType;
 import org.elasticsearch.index.query.SearchExecutionContext;
 import org.elasticsearch.script.LongFieldScript;
+import org.elasticsearch.script.CompositeFieldScript;
 import org.elasticsearch.script.Script;
 import org.elasticsearch.search.DocValueFormat;
 import org.elasticsearch.search.lookup.SearchLookup;
@@ -29,6 +30,7 @@ import org.elasticsearch.search.runtime.LongScriptFieldTermsQuery;
 import java.time.ZoneId;
 import java.util.Collection;
 import java.util.Map;
+import java.util.function.Function;
 import java.util.function.Supplier;
 
 public final class LongScriptFieldType extends AbstractScriptFieldType<LongFieldScript.LeafFactory> {
@@ -37,13 +39,23 @@ public final class LongScriptFieldType extends AbstractScriptFieldType<LongField
 
     private static class Builder extends AbstractScriptFieldType.Builder<LongFieldScript.Factory> {
         Builder(String name) {
-            super(name, LongFieldScript.CONTEXT, LongFieldScript.PARSE_FROM_SOURCE);
+            super(name, LongFieldScript.CONTEXT);
         }
 
         @Override
         AbstractScriptFieldType<?> createFieldType(String name, LongFieldScript.Factory factory, Script script, Map<String, String> meta) {
             return new LongScriptFieldType(name, factory, script, meta);
         }
+
+        @Override
+        LongFieldScript.Factory getParseFromSourceFactory() {
+            return LongFieldScript.PARSE_FROM_SOURCE;
+        }
+
+        @Override
+        LongFieldScript.Factory getCompositeLeafFactory(Function<SearchLookup, CompositeFieldScript.LeafFactory> parentScriptFactory) {
+            return LongFieldScript.leafAdapter(parentScriptFactory);
+        }
     }
 
     public static RuntimeField sourceOnly(String name) {
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/MappingLookup.java b/server/src/main/java/org/elasticsearch/index/mapper/MappingLookup.java
index c38d9a7b6e6b..5d8fc7138ec5 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/MappingLookup.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/MappingLookup.java
@@ -161,9 +161,7 @@ public final class MappingLookup {
 
         this.shadowedFields = new HashSet<>();
         for (RuntimeField runtimeField : mapping.getRoot().runtimeFields()) {
-            for (MappedFieldType mft : runtimeField.asMappedFieldTypes()) {
-                shadowedFields.add(mft.name());
-            }
+            runtimeField.asMappedFieldTypes().forEach(mft -> shadowedFields.add(mft.name()));
         }
 
         this.fieldTypeLookup = new FieldTypeLookup(mappers, aliasMappers, mapping.getRoot().runtimeFields());
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/RootObjectMapper.java b/server/src/main/java/org/elasticsearch/index/mapper/RootObjectMapper.java
index a96bed13a69c..16f4dc5fe6ea 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/RootObjectMapper.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/RootObjectMapper.java
@@ -214,7 +214,12 @@ public class RootObjectMapper extends ObjectMapper {
                 return true;
             } else if (fieldName.equals("runtime")) {
                 if (fieldNode instanceof Map) {
-                    builder.setRuntime(RuntimeField.parseRuntimeFields((Map<String, Object>) fieldNode, parserContext, true));
+                    Map<String, RuntimeField> fields = RuntimeField.parseRuntimeFields(
+                        (Map<String, Object>) fieldNode,
+                        parserContext,
+                        true
+                    );
+                    builder.setRuntime(fields);
                     return true;
                 } else {
                     throw new ElasticsearchParseException("runtime must be a map type");
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/RuntimeField.java b/server/src/main/java/org/elasticsearch/index/mapper/RuntimeField.java
index 78e8f078804f..c2f342a610bd 100644
--- a/server/src/main/java/org/elasticsearch/index/mapper/RuntimeField.java
+++ b/server/src/main/java/org/elasticsearch/index/mapper/RuntimeField.java
@@ -10,6 +10,10 @@ package org.elasticsearch.index.mapper;
 
 import org.elasticsearch.common.xcontent.ToXContentFragment;
 import org.elasticsearch.index.mapper.FieldMapper.Parameter;
+import org.elasticsearch.script.CompositeFieldScript;
+import org.elasticsearch.script.Script;
+import org.elasticsearch.script.ScriptType;
+import org.elasticsearch.search.lookup.SearchLookup;
 
 import java.util.Collection;
 import java.util.Collections;
@@ -19,6 +23,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * Definition of a runtime field that can be defined as part of the runtime section of the index mappings
@@ -35,7 +40,7 @@ public interface RuntimeField extends ToXContentFragment {
      * Exposes the {@link MappedFieldType}s backing this runtime field, used to execute queries, run aggs etc.
      * @return the {@link MappedFieldType}s backing this runtime field
      */
-    Collection<MappedFieldType> asMappedFieldTypes();
+    Stream<MappedFieldType> asMappedFieldTypes();
 
     abstract class Builder {
         final String name;
@@ -55,6 +60,12 @@ public interface RuntimeField extends ToXContentFragment {
 
         protected abstract RuntimeField createRuntimeField(MappingParserContext parserContext);
 
+        protected abstract RuntimeField createChildRuntimeField(
+            MappingParserContext parserContext,
+            String parentName,
+            Function<SearchLookup, CompositeFieldScript.LeafFactory> parentScriptFactory
+        );
+
         public final void parse(String name, MappingParserContext parserContext, Map<String, Object> fieldNode) {
             Map<String, Parameter<?>> paramsMap = new HashMap<>();
             for (Parameter<?> param : getParameters()) {
@@ -78,6 +89,9 @@ public interface RuntimeField extends ToXContentFragment {
                 parameter.parse(name, parserContext, propNode);
                 iterator.remove();
             }
+            for (Parameter<?> parameter : getParameters()) {
+                parameter.validate();
+            }
         }
     }
 
@@ -92,12 +106,14 @@ public interface RuntimeField extends ToXContentFragment {
             this.builderFunction = builderFunction;
         }
 
-        RuntimeField parse(String name, Map<String, Object> node, MappingParserContext parserContext)
+        RuntimeField.Builder parse(String name,
+                           Map<String, Object> node,
+                           MappingParserContext parserContext)
             throws MapperParsingException {
 
             RuntimeField.Builder builder = builderFunction.apply(name);
             builder.parse(name, parserContext, node);
-            return builder.createRuntimeField(parserContext);
+            return builder;
         }
     }
 
@@ -112,6 +128,27 @@ public interface RuntimeField extends ToXContentFragment {
     static Map<String, RuntimeField> parseRuntimeFields(Map<String, Object> node,
                                                         MappingParserContext parserContext,
                                                         boolean supportsRemoval) {
+        return parseRuntimeFields(node, parserContext, b -> b.createRuntimeField(parserContext), supportsRemoval);
+    }
+
+    /**
+     * Parse runtime fields from the provided map, using the provided parser context.
+     *
+     * This method also allows you to define how the runtime field will be created from its
+     * builder, so that it can be used by composite fields to build child fields using
+     * parent factory parameters.
+     *
+     * @param node the map that holds the runtime fields configuration
+     * @param parserContext the parser context that holds info needed when parsing mappings
+     * @param builder a function to convert a RuntimeField.Builder into a RuntimeField
+     * @param supportsRemoval whether a null value for a runtime field should be properly parsed and
+     *                        translated to the removal of such runtime field
+     * @return the parsed runtime fields
+     */
+    static Map<String, RuntimeField> parseRuntimeFields(Map<String, Object> node,
+                                                        MappingParserContext parserContext,
+                                                        Function<RuntimeField.Builder, RuntimeField> builder,
+                                                        boolean supportsRemoval) {
         Map<String, RuntimeField> runtimeFields = new HashMap<>();
         Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator();
         while (iterator.hasNext()) {
@@ -139,7 +176,7 @@ public interface RuntimeField extends ToXContentFragment {
                     throw new MapperParsingException("No handler for type [" + type +
                         "] declared on runtime field [" + fieldName + "]");
                 }
-                runtimeFields.put(fieldName, typeParser.parse(fieldName, propNode, parserContext));
+                runtimeFields.put(fieldName, builder.apply(typeParser.parse(fieldName, propNode, parserContext)));
                 propNode.remove("type");
                 MappingParser.checkNoRemainingFields(fieldName, propNode);
                 iterator.remove();
@@ -161,7 +198,7 @@ public interface RuntimeField extends ToXContentFragment {
     static Map<String, MappedFieldType> collectFieldTypes(Collection<RuntimeField> runtimeFields) {
         return runtimeFields.stream()
             .flatMap(runtimeField -> {
-                List<String> names = runtimeField.asMappedFieldTypes().stream().map(MappedFieldType::name)
+                List<String> names = runtimeField.asMappedFieldTypes().map(MappedFieldType::name)
                     .filter(name -> name.equals(runtimeField.name()) == false
                         && (name.startsWith(runtimeField.name() + ".") == false
                         || name.length() > runtimeField.name().length() + 1 == false))
@@ -170,11 +207,23 @@ public interface RuntimeField extends ToXContentFragment {
                     throw new IllegalStateException("Found sub-fields with name not belonging to the parent field they are part of "
                         + names);
                 }
-                return runtimeField.asMappedFieldTypes().stream();
+                return runtimeField.asMappedFieldTypes();
             })
             .collect(Collectors.toUnmodifiableMap(MappedFieldType::name, mappedFieldType -> mappedFieldType,
                 (t, t2) -> {
                     throw new IllegalArgumentException("Found two runtime fields with same name [" + t.name() + "]");
                 }));
     }
+
+    static <T> Function<FieldMapper, T> initializerNotSupported() {
+        return mapper -> { throw new UnsupportedOperationException(); };
+    }
+
+    static Script parseScript(String name, MappingParserContext parserContext, Object scriptObject) {
+        Script script = Script.parse(scriptObject);
+        if (script.getType() == ScriptType.STORED) {
+            throw new IllegalArgumentException("stored scripts are not supported for runtime field [" + name + "]");
+        }
+        return script;
+    }
 }
diff --git a/server/src/main/java/org/elasticsearch/index/query/SearchExecutionContext.java b/server/src/main/java/org/elasticsearch/index/query/SearchExecutionContext.java
index 6eb8abe7dcdc..dc3b3bf84f92 100644
--- a/server/src/main/java/org/elasticsearch/index/query/SearchExecutionContext.java
+++ b/server/src/main/java/org/elasticsearch/index/query/SearchExecutionContext.java
@@ -635,8 +635,12 @@ public class SearchExecutionContext extends QueryRewriteContext {
         if (runtimeMappings.isEmpty()) {
             return Collections.emptyMap();
         }
-        Map<String, RuntimeField> runtimeFields = RuntimeField.parseRuntimeFields(new HashMap<>(runtimeMappings),
-            mapperService.parserContext(), false);
+        //TODO add specific tests to SearchExecutionTests similar to the ones in FieldTypeLookupTests
+        MappingParserContext parserContext = mapperService.parserContext();
+        Map<String, RuntimeField> runtimeFields = RuntimeField.parseRuntimeFields(
+            new HashMap<>(runtimeMappings),
+            parserContext,
+            false);
         return RuntimeField.collectFieldTypes(runtimeFields.values());
     }
 
diff --git a/server/src/main/java/org/elasticsearch/indices/IndicesModule.java b/server/src/main/java/org/elasticsearch/indices/IndicesModule.java
index e5bffcd4f8df..3419d32947e3 100644
--- a/server/src/main/java/org/elasticsearch/indices/IndicesModule.java
+++ b/server/src/main/java/org/elasticsearch/indices/IndicesModule.java
@@ -20,17 +20,24 @@ import org.elasticsearch.common.io.stream.NamedWriteableRegistry;
 import org.elasticsearch.common.xcontent.NamedXContentRegistry;
 import org.elasticsearch.index.mapper.BinaryFieldMapper;
 import org.elasticsearch.index.mapper.BooleanFieldMapper;
+import org.elasticsearch.index.mapper.BooleanScriptFieldType;
 import org.elasticsearch.index.mapper.CompletionFieldMapper;
 import org.elasticsearch.index.mapper.DateFieldMapper;
+import org.elasticsearch.index.mapper.DateScriptFieldType;
 import org.elasticsearch.index.mapper.DocCountFieldMapper;
+import org.elasticsearch.index.mapper.DoubleScriptFieldType;
 import org.elasticsearch.index.mapper.FieldAliasMapper;
 import org.elasticsearch.index.mapper.FieldNamesFieldMapper;
 import org.elasticsearch.index.mapper.GeoPointFieldMapper;
+import org.elasticsearch.index.mapper.GeoPointScriptFieldType;
 import org.elasticsearch.index.mapper.IdFieldMapper;
 import org.elasticsearch.index.mapper.IgnoredFieldMapper;
 import org.elasticsearch.index.mapper.IndexFieldMapper;
 import org.elasticsearch.index.mapper.IpFieldMapper;
+import org.elasticsearch.index.mapper.IpScriptFieldType;
 import org.elasticsearch.index.mapper.KeywordFieldMapper;
+import org.elasticsearch.index.mapper.KeywordScriptFieldType;
+import org.elasticsearch.index.mapper.LongScriptFieldType;
 import org.elasticsearch.index.mapper.Mapper;
 import org.elasticsearch.index.mapper.MapperRegistry;
 import org.elasticsearch.index.mapper.MetadataFieldMapper;
@@ -38,6 +45,7 @@ import org.elasticsearch.index.mapper.NestedObjectMapper;
 import org.elasticsearch.index.mapper.NestedPathFieldMapper;
 import org.elasticsearch.index.mapper.NumberFieldMapper;
 import org.elasticsearch.index.mapper.ObjectMapper;
+import org.elasticsearch.index.mapper.CompositeRuntimeField;
 import org.elasticsearch.index.mapper.RangeType;
 import org.elasticsearch.index.mapper.RoutingFieldMapper;
 import org.elasticsearch.index.mapper.RuntimeField;
@@ -53,13 +61,6 @@ import org.elasticsearch.index.shard.PrimaryReplicaSyncer;
 import org.elasticsearch.indices.cluster.IndicesClusterStateService;
 import org.elasticsearch.indices.store.IndicesStore;
 import org.elasticsearch.plugins.MapperPlugin;
-import org.elasticsearch.index.mapper.BooleanScriptFieldType;
-import org.elasticsearch.index.mapper.DateScriptFieldType;
-import org.elasticsearch.index.mapper.DoubleScriptFieldType;
-import org.elasticsearch.index.mapper.GeoPointScriptFieldType;
-import org.elasticsearch.index.mapper.IpScriptFieldType;
-import org.elasticsearch.index.mapper.KeywordScriptFieldType;
-import org.elasticsearch.index.mapper.LongScriptFieldType;
 
 import java.util.Arrays;
 import java.util.Collections;
@@ -150,6 +151,7 @@ public class IndicesModule extends AbstractModule {
         runtimeParsers.put(DateFieldMapper.CONTENT_TYPE, DateScriptFieldType.PARSER);
         runtimeParsers.put(KeywordFieldMapper.CONTENT_TYPE, KeywordScriptFieldType.PARSER);
         runtimeParsers.put(GeoPointFieldMapper.CONTENT_TYPE, GeoPointScriptFieldType.PARSER);
+        runtimeParsers.put(CompositeRuntimeField.CONTENT_TYPE, CompositeRuntimeField.PARSER);
 
         for (MapperPlugin mapperPlugin : mapperPlugins) {
             for (Map.Entry<String, RuntimeField.Parser> entry : mapperPlugin.getRuntimeFields().entrySet()) {
diff --git a/server/src/main/java/org/elasticsearch/script/AbstractFieldScript.java b/server/src/main/java/org/elasticsearch/script/AbstractFieldScript.java
index c4cb89e8f5e2..27f653980177 100644
--- a/server/src/main/java/org/elasticsearch/script/AbstractFieldScript.java
+++ b/server/src/main/java/org/elasticsearch/script/AbstractFieldScript.java
@@ -86,7 +86,7 @@ public abstract class AbstractFieldScript extends DocBasedScript {
     /**
      * Set the document to run the script against.
      */
-    public final void setDocument(int docId) {
+    public void setDocument(int docId) {
         this.leafSearchLookup.setDocument(docId);
     }
 
@@ -108,6 +108,16 @@ public abstract class AbstractFieldScript extends DocBasedScript {
         return XContentMapValues.extractRawValues(path, leafSearchLookup.source().source());
     }
 
+    protected final void emitFromCompositeScript(CompositeFieldScript compositeFieldScript) {
+        List<Object> values = compositeFieldScript.getValues(fieldName);
+        if (values == null) {
+            return;
+        }
+        for (Object value : values) {
+            emitFromObject(value);
+        }
+    }
+
     protected abstract void emitFromObject(Object v);
 
     protected final void emitFromSource() {
diff --git a/server/src/main/java/org/elasticsearch/script/BooleanFieldScript.java b/server/src/main/java/org/elasticsearch/script/BooleanFieldScript.java
index 00027d6cc735..fe2f8e6a6338 100644
--- a/server/src/main/java/org/elasticsearch/script/BooleanFieldScript.java
+++ b/server/src/main/java/org/elasticsearch/script/BooleanFieldScript.java
@@ -14,6 +14,7 @@ import org.elasticsearch.search.lookup.SearchLookup;
 
 import java.util.Map;
 import java.util.function.Consumer;
+import java.util.function.Function;
 
 public abstract class BooleanFieldScript extends AbstractFieldScript {
 
@@ -33,6 +34,26 @@ public abstract class BooleanFieldScript extends AbstractFieldScript {
         }
     };
 
+    public static Factory leafAdapter(Function<SearchLookup, CompositeFieldScript.LeafFactory> parentFactory) {
+        return (leafFieldName, params, searchLookup) -> {
+            CompositeFieldScript.LeafFactory parentLeafFactory = parentFactory.apply(searchLookup);
+            return (LeafFactory) ctx -> {
+                CompositeFieldScript compositeFieldScript = parentLeafFactory.newInstance(ctx);
+                return new BooleanFieldScript(leafFieldName, params, searchLookup, ctx) {
+                    @Override
+                    public void setDocument(int docId) {
+                        compositeFieldScript.setDocument(docId);
+                    }
+
+                    @Override
+                    public void execute() {
+                        emitFromCompositeScript(compositeFieldScript);
+                    }
+                };
+            };
+        };
+    }
+
     @SuppressWarnings("unused")
     public static final String[] PARAMETERS = {};
 
diff --git a/server/src/main/java/org/elasticsearch/script/CompositeFieldScript.java b/server/src/main/java/org/elasticsearch/script/CompositeFieldScript.java
new file mode 100644
index 000000000000..449a66fb21bf
--- /dev/null
+++ b/server/src/main/java/org/elasticsearch/script/CompositeFieldScript.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.script;
+
+import org.apache.lucene.index.LeafReaderContext;
+import org.elasticsearch.search.lookup.SearchLookup;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * A script that emits a map of multiple values, that can then be accessed
+ * by child runtime fields.
+ */
+public abstract class CompositeFieldScript extends AbstractFieldScript {
+    public static final ScriptContext<CompositeFieldScript.Factory> CONTEXT = newContext("composite_field", Factory.class);
+
+    @SuppressWarnings("unused")
+    public static final String[] PARAMETERS = {};
+
+    public interface Factory extends ScriptFactory {
+        CompositeFieldScript.LeafFactory newFactory(String fieldName, Map<String, Object> params, SearchLookup searchLookup);
+    }
+
+    public interface LeafFactory {
+        CompositeFieldScript newInstance(LeafReaderContext ctx);
+    }
+
+    private final Map<String, List<Object>> fieldValues = new HashMap<>();
+
+    public CompositeFieldScript(String fieldName, Map<String, Object> params, SearchLookup searchLookup, LeafReaderContext ctx) {
+        super(fieldName, params, searchLookup, ctx);
+    }
+
+    /**
+     * Runs the object script and returns the values that were emitted for the provided field name
+     * @param field the field name to extract values from
+     * @return the values that were emitted for the provided field
+     */
+    public final List<Object> getValues(String field) {
+        //TODO for now we re-run the script every time a leaf field is accessed, but we could cache the values?
+        fieldValues.clear();
+        execute();
+        List<Object> values = fieldValues.get(field);
+        fieldValues.clear();    // don't hold on to values unnecessarily
+        return values;
+    }
+
+    public final Map<String, List<Object>> runForDoc(int doc) {
+        setDocument(doc);
+        fieldValues.clear();
+        execute();
+        return fieldValues;
+    }
+
+    protected final void emit(String field, Object value) {
+        //fields will be emitted without the prefix, yet they will be looked up using their full name, hence we store the full name
+        List<Object> values = this.fieldValues.computeIfAbsent(fieldName + "." + field, s -> new ArrayList<>());
+        values.add(value);
+    }
+
+    @Override
+    protected void emitFromObject(Object v) {
+        throw new UnsupportedOperationException();
+    }
+
+    public static class EmitField {
+        private final CompositeFieldScript script;
+
+        public EmitField(CompositeFieldScript script) {
+            this.script = script;
+        }
+
+        /**
+         * Emits a value for the provided field. Note that ideally we would have typed the value, and have
+         * one emit per supported data type, but the arity in Painless does not take arguments type into account, only method name and
+         * number of arguments. That means that we would have needed a different method name per type, and given that we need the Object
+         * variant anyways to be able to emit an entire map, we went for taking an object also for the keyed emit variant.
+         *
+         * @param field the field name
+         * @param value the value
+         */
+        public void emit(String field, Object value) {
+            script.emit(field, value);
+        }
+    }
+
+    public static class EmitMap {
+        private final CompositeFieldScript script;
+
+        public EmitMap(CompositeFieldScript script) {
+            this.script = script;
+        }
+
+        /**
+         * Emits all the subfields in one go. The key in the provided map is the field name, and the value their value(s)
+         * @param subfields the map that holds the key-value pairs
+         */
+        public void emit(Map<String, Object> subfields) {
+            if (subfields == null) {
+                return;
+            }
+            for (Map.Entry<String, Object> entry : subfields.entrySet()) {
+                script.emit(entry.getKey(), entry.getValue());
+            }
+        }
+    }
+}
diff --git a/server/src/main/java/org/elasticsearch/script/DateFieldScript.java b/server/src/main/java/org/elasticsearch/script/DateFieldScript.java
index e97f4584e622..7cda02b1e85d 100644
--- a/server/src/main/java/org/elasticsearch/script/DateFieldScript.java
+++ b/server/src/main/java/org/elasticsearch/script/DateFieldScript.java
@@ -14,6 +14,7 @@ import org.elasticsearch.search.lookup.SearchLookup;
 
 import java.util.Map;
 import java.util.Objects;
+import java.util.function.Function;
 
 public abstract class DateFieldScript extends AbstractLongFieldScript {
     public static final ScriptContext<Factory> CONTEXT = newContext("date_field", Factory.class);
@@ -33,6 +34,26 @@ public abstract class DateFieldScript extends AbstractLongFieldScript {
         }
     };
 
+    public static Factory leafAdapter(Function<SearchLookup, CompositeFieldScript.LeafFactory> parentFactory) {
+        return (leafFieldName, params, searchLookup, formatter) -> {
+            CompositeFieldScript.LeafFactory parentLeafFactory = parentFactory.apply(searchLookup);
+            return (LeafFactory) ctx -> {
+                CompositeFieldScript compositeFieldScript = parentLeafFactory.newInstance(ctx);
+                return new DateFieldScript(leafFieldName, params, searchLookup, formatter, ctx) {
+                    @Override
+                    public void setDocument(int docId) {
+                        compositeFieldScript.setDocument(docId);
+                    }
+
+                    @Override
+                    public void execute() {
+                        emitFromCompositeScript(compositeFieldScript);
+                    }
+                };
+            };
+        };
+    }
+
     @SuppressWarnings("unused")
     public static final String[] PARAMETERS = {};
 
diff --git a/server/src/main/java/org/elasticsearch/script/DoubleFieldScript.java b/server/src/main/java/org/elasticsearch/script/DoubleFieldScript.java
index 8baaa9f56b1e..5dc0725f4b3d 100644
--- a/server/src/main/java/org/elasticsearch/script/DoubleFieldScript.java
+++ b/server/src/main/java/org/elasticsearch/script/DoubleFieldScript.java
@@ -14,6 +14,7 @@ import org.elasticsearch.search.lookup.SearchLookup;
 
 import java.util.Map;
 import java.util.function.DoubleConsumer;
+import java.util.function.Function;
 
 public abstract class DoubleFieldScript extends AbstractFieldScript {
     public static final ScriptContext<Factory> CONTEXT = newContext("double_field", Factory.class);
@@ -32,6 +33,26 @@ public abstract class DoubleFieldScript extends AbstractFieldScript {
         }
     };
 
+    public static Factory leafAdapter(Function<SearchLookup, CompositeFieldScript.LeafFactory> parentFactory) {
+        return (leafFieldName, params, searchLookup) -> {
+            CompositeFieldScript.LeafFactory parentLeafFactory = parentFactory.apply(searchLookup);
+            return (LeafFactory) ctx -> {
+                CompositeFieldScript compositeFieldScript = parentLeafFactory.newInstance(ctx);
+                return new DoubleFieldScript(leafFieldName, params, searchLookup, ctx) {
+                    @Override
+                    public void setDocument(int docId) {
+                        compositeFieldScript.setDocument(docId);
+                    }
+
+                    @Override
+                    public void execute() {
+                        emitFromCompositeScript(compositeFieldScript);
+                    }
+                };
+            };
+        };
+    }
+
     @SuppressWarnings("unused")
     public static final String[] PARAMETERS = {};
 
diff --git a/server/src/main/java/org/elasticsearch/script/GeoPointFieldScript.java b/server/src/main/java/org/elasticsearch/script/GeoPointFieldScript.java
index f3c54a11d0a1..5773fc7bca93 100644
--- a/server/src/main/java/org/elasticsearch/script/GeoPointFieldScript.java
+++ b/server/src/main/java/org/elasticsearch/script/GeoPointFieldScript.java
@@ -20,6 +20,7 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Consumer;
+import java.util.function.Function;
 
 import static org.apache.lucene.geo.GeoEncodingUtils.encodeLatitude;
 import static org.apache.lucene.geo.GeoEncodingUtils.encodeLongitude;
@@ -46,6 +47,26 @@ public abstract class GeoPointFieldScript extends AbstractLongFieldScript {
         }
     };
 
+    public static Factory leafAdapter(Function<SearchLookup, CompositeFieldScript.LeafFactory> parentFactory) {
+        return (leafFieldName, params, searchLookup) -> {
+            CompositeFieldScript.LeafFactory parentLeafFactory = parentFactory.apply(searchLookup);
+            return (LeafFactory) ctx -> {
+                CompositeFieldScript compositeFieldScript = parentLeafFactory.newInstance(ctx);
+                return new GeoPointFieldScript(leafFieldName, params, searchLookup, ctx) {
+                    @Override
+                    public void setDocument(int docId) {
+                        compositeFieldScript.setDocument(docId);
+                    }
+
+                    @Override
+                    public void execute() {
+                        emitFromCompositeScript(compositeFieldScript);
+                    }
+                };
+            };
+        };
+    }
+
     @SuppressWarnings("unused")
     public static final String[] PARAMETERS = {};
 
diff --git a/server/src/main/java/org/elasticsearch/script/IpFieldScript.java b/server/src/main/java/org/elasticsearch/script/IpFieldScript.java
index ca202b1d4610..cc36dc8888d3 100644
--- a/server/src/main/java/org/elasticsearch/script/IpFieldScript.java
+++ b/server/src/main/java/org/elasticsearch/script/IpFieldScript.java
@@ -21,6 +21,7 @@ import java.net.Inet6Address;
 import java.net.InetAddress;
 import java.util.Map;
 import java.util.function.Consumer;
+import java.util.function.Function;
 
 /**
  * Script producing IP addresses. Unlike the other {@linkplain AbstractFieldScript}s
@@ -53,6 +54,26 @@ public abstract class IpFieldScript extends AbstractFieldScript {
         }
     };
 
+    public static Factory leafAdapter(Function<SearchLookup, CompositeFieldScript.LeafFactory> parentFactory) {
+        return (leafFieldName, params, searchLookup) -> {
+            CompositeFieldScript.LeafFactory parentLeafFactory = parentFactory.apply(searchLookup);
+            return (LeafFactory) ctx -> {
+                CompositeFieldScript compositeFieldScript = parentLeafFactory.newInstance(ctx);
+                return new IpFieldScript(leafFieldName, params, searchLookup, ctx) {
+                    @Override
+                    public void setDocument(int docId) {
+                        compositeFieldScript.setDocument(docId);
+                    }
+
+                    @Override
+                    public void execute() {
+                        emitFromCompositeScript(compositeFieldScript);
+                    }
+                };
+            };
+        };
+    }
+
     @SuppressWarnings("unused")
     public static final String[] PARAMETERS = {};
 
diff --git a/server/src/main/java/org/elasticsearch/script/LongFieldScript.java b/server/src/main/java/org/elasticsearch/script/LongFieldScript.java
index afceda325d26..cf58561d1215 100644
--- a/server/src/main/java/org/elasticsearch/script/LongFieldScript.java
+++ b/server/src/main/java/org/elasticsearch/script/LongFieldScript.java
@@ -13,6 +13,7 @@ import org.elasticsearch.index.mapper.NumberFieldMapper;
 import org.elasticsearch.search.lookup.SearchLookup;
 
 import java.util.Map;
+import java.util.function.Function;
 
 public abstract class LongFieldScript extends AbstractLongFieldScript {
     public static final ScriptContext<Factory> CONTEXT = newContext("long_field", Factory.class);
@@ -31,6 +32,26 @@ public abstract class LongFieldScript extends AbstractLongFieldScript {
         }
     };
 
+    public static Factory leafAdapter(Function<SearchLookup, CompositeFieldScript.LeafFactory> parentFactory) {
+        return (leafFieldName, params, searchLookup) -> {
+            CompositeFieldScript.LeafFactory parentLeafFactory = parentFactory.apply(searchLookup);
+            return (LeafFactory) ctx -> {
+                CompositeFieldScript compositeFieldScript = parentLeafFactory.newInstance(ctx);
+                return new LongFieldScript(leafFieldName, params, searchLookup, ctx) {
+                    @Override
+                    public void setDocument(int docId) {
+                        compositeFieldScript.setDocument(docId);
+                    }
+
+                    @Override
+                    public void execute() {
+                        emitFromCompositeScript(compositeFieldScript);
+                    }
+                };
+            };
+        };
+    }
+
     @SuppressWarnings("unused")
     public static final String[] PARAMETERS = {};
 
diff --git a/server/src/main/java/org/elasticsearch/script/ScriptModule.java b/server/src/main/java/org/elasticsearch/script/ScriptModule.java
index 2bd85bec4629..b8d33dab9aa2 100644
--- a/server/src/main/java/org/elasticsearch/script/ScriptModule.java
+++ b/server/src/main/java/org/elasticsearch/script/ScriptModule.java
@@ -28,8 +28,15 @@ import java.util.stream.Stream;
  */
 public class ScriptModule {
 
-    public static final Set<ScriptContext<?>> RUNTIME_FIELDS_CONTEXTS = Set.of(BooleanFieldScript.CONTEXT, DateFieldScript.CONTEXT,
-        DoubleFieldScript.CONTEXT, LongFieldScript.CONTEXT, StringFieldScript.CONTEXT, GeoPointFieldScript.CONTEXT, IpFieldScript.CONTEXT);
+    public static final Set<ScriptContext<?>> RUNTIME_FIELDS_CONTEXTS = Set.of(
+        BooleanFieldScript.CONTEXT,
+        DateFieldScript.CONTEXT,
+        DoubleFieldScript.CONTEXT,
+        LongFieldScript.CONTEXT,
+        StringFieldScript.CONTEXT,
+        GeoPointFieldScript.CONTEXT,
+        IpFieldScript.CONTEXT,
+        CompositeFieldScript.CONTEXT);
 
     public static final Map<String, ScriptContext<?>> CORE_CONTEXTS;
     static {
diff --git a/server/src/main/java/org/elasticsearch/script/StringFieldScript.java b/server/src/main/java/org/elasticsearch/script/StringFieldScript.java
index a8c6f1ff8470..14fecf6753b3 100644
--- a/server/src/main/java/org/elasticsearch/script/StringFieldScript.java
+++ b/server/src/main/java/org/elasticsearch/script/StringFieldScript.java
@@ -16,6 +16,7 @@ import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.function.Consumer;
+import java.util.function.Function;
 
 public abstract class StringFieldScript extends AbstractFieldScript {
     /**
@@ -39,6 +40,26 @@ public abstract class StringFieldScript extends AbstractFieldScript {
         }
     };
 
+    public static Factory leafAdapter(Function<SearchLookup, CompositeFieldScript.LeafFactory> parentFactory) {
+        return (leafFieldName, params, searchLookup) -> {
+            CompositeFieldScript.LeafFactory parentLeafFactory = parentFactory.apply(searchLookup);
+            return (LeafFactory) ctx -> {
+                CompositeFieldScript compositeFieldScript = parentLeafFactory.newInstance(ctx);
+                return new StringFieldScript(leafFieldName, params, searchLookup, ctx) {
+                    @Override
+                    public void setDocument(int docId) {
+                        compositeFieldScript.setDocument(docId);
+                    }
+
+                    @Override
+                    public void execute() {
+                        emitFromCompositeScript(compositeFieldScript);
+                    }
+                };
+            };
+        };
+    }
+
     @SuppressWarnings("unused")
     public static final String[] PARAMETERS = {};
 
diff --git a/server/src/test/java/org/elasticsearch/index/mapper/CompositeRuntimeFieldTests.java b/server/src/test/java/org/elasticsearch/index/mapper/CompositeRuntimeFieldTests.java
new file mode 100644
index 000000000000..72d7df28c570
--- /dev/null
+++ b/server/src/test/java/org/elasticsearch/index/mapper/CompositeRuntimeFieldTests.java
@@ -0,0 +1,438 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.index.mapper;
+
+import org.elasticsearch.common.Strings;
+import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.common.xcontent.XContentType;
+import org.elasticsearch.script.LongFieldScript;
+import org.elasticsearch.script.CompositeFieldScript;
+import org.elasticsearch.script.Script;
+import org.elasticsearch.script.ScriptContext;
+import org.elasticsearch.search.lookup.LeafSearchLookup;
+import org.elasticsearch.search.lookup.SearchLookup;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.hamcrest.Matchers.containsString;
+
+public class CompositeRuntimeFieldTests extends MapperServiceTestCase {
+
+    @Override
+    @SuppressWarnings("unchecked")
+    protected <T> T compileScript(Script script, ScriptContext<T> context) {
+        if (context == CompositeFieldScript.CONTEXT) {
+            return (T) (CompositeFieldScript.Factory) (fieldName, params, searchLookup) -> ctx -> new CompositeFieldScript(
+                fieldName,
+                params,
+                searchLookup,
+                ctx
+            ){
+                @Override
+                public void execute() {
+                    if (script.getIdOrCode().equals("split-str-long")) {
+                        List<Object> values = extractFromSource("field");
+                        String input = values.get(0).toString();
+                        String[] parts = input.split(" ");
+                        emit("str", parts[0]);
+                        emit("long", parts[1]);
+                    }
+                }
+            };
+        }
+        if (context == LongFieldScript.CONTEXT) {
+            return (T) (LongFieldScript.Factory) (field, params, lookup) -> ctx -> new LongFieldScript(field, params, lookup, ctx) {
+                @Override
+                public void execute() {
+
+                }
+            };
+        }
+        throw new UnsupportedOperationException("Unknown context " + context.name);
+    }
+
+    public void testObjectDefinition() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {
+            b.startObject("runtime");
+            b.startObject("obj");
+            b.field("type", "composite");
+            b.startObject("script").field("source", "dummy").endObject();
+            b.startObject("fields");
+            b.startObject("long-subfield").field("type", "long").endObject();
+            b.startObject("str-subfield").field("type", "keyword").endObject();
+            b.startObject("double-subfield").field("type", "double").endObject();
+            b.startObject("boolean-subfield").field("type", "boolean").endObject();
+            b.startObject("ip-subfield").field("type", "ip").endObject();
+            b.startObject("geopoint-subfield").field("type", "geo_point").endObject();
+            b.endObject();
+            b.endObject();
+            b.endObject();
+        }));
+
+        assertNull(mapperService.mappingLookup().getFieldType("obj"));
+        assertNull(mapperService.mappingLookup().getFieldType("long-subfield"));
+        assertNull(mapperService.mappingLookup().getFieldType("str-subfield"));
+        assertNull(mapperService.mappingLookup().getFieldType("double-subfield"));
+        assertNull(mapperService.mappingLookup().getFieldType("boolean-subfield"));
+        assertNull(mapperService.mappingLookup().getFieldType("ip-subfield"));
+        assertNull(mapperService.mappingLookup().getFieldType("geopoint-subfield"));
+        assertNull(mapperService.mappingLookup().getFieldType("obj.any-subfield"));
+        MappedFieldType longSubfield = mapperService.mappingLookup().getFieldType("obj.long-subfield");
+        assertEquals("obj.long-subfield", longSubfield.name());
+        assertEquals("long", longSubfield.typeName());
+        MappedFieldType strSubfield = mapperService.mappingLookup().getFieldType("obj.str-subfield");
+        assertEquals("obj.str-subfield", strSubfield.name());
+        assertEquals("keyword", strSubfield.typeName());
+        MappedFieldType doubleSubfield = mapperService.mappingLookup().getFieldType("obj.double-subfield");
+        assertEquals("obj.double-subfield", doubleSubfield.name());
+        assertEquals("double", doubleSubfield.typeName());
+        MappedFieldType booleanSubfield = mapperService.mappingLookup().getFieldType("obj.boolean-subfield");
+        assertEquals("obj.boolean-subfield", booleanSubfield.name());
+        assertEquals("boolean", booleanSubfield.typeName());
+        MappedFieldType ipSubfield = mapperService.mappingLookup().getFieldType("obj.ip-subfield");
+        assertEquals("obj.ip-subfield", ipSubfield.name());
+        assertEquals("ip", ipSubfield.typeName());
+        MappedFieldType geoPointSubfield = mapperService.mappingLookup().getFieldType("obj.geopoint-subfield");
+        assertEquals("obj.geopoint-subfield", geoPointSubfield.name());
+        assertEquals("geo_point", geoPointSubfield.typeName());
+
+        RuntimeField rf = mapperService.mappingLookup().getMapping().getRoot().getRuntimeField("obj");
+        assertEquals("obj", rf.name());
+        Collection<MappedFieldType> mappedFieldTypes = rf.asMappedFieldTypes().collect(Collectors.toList());
+        for (MappedFieldType mappedFieldType : mappedFieldTypes) {
+            if (mappedFieldType.name().equals("obj.long-subfield")) {
+                assertSame(longSubfield, mappedFieldType);
+            } else if (mappedFieldType.name().equals("obj.str-subfield")) {
+                assertSame(strSubfield, mappedFieldType);
+            }  else if (mappedFieldType.name().equals("obj.double-subfield")) {
+                assertSame(doubleSubfield, mappedFieldType);
+            }  else if (mappedFieldType.name().equals("obj.boolean-subfield")) {
+                assertSame(booleanSubfield, mappedFieldType);
+            }  else if (mappedFieldType.name().equals("obj.ip-subfield")) {
+                assertSame(ipSubfield, mappedFieldType);
+            }  else if (mappedFieldType.name().equals("obj.geopoint-subfield")) {
+                assertSame(geoPointSubfield, mappedFieldType);
+            } else {
+                fail("unexpected subfield [" + mappedFieldType.name() + "]");
+            }
+        }
+    }
+
+    public void testUnsupportedLeafType() {
+        Exception e = expectThrows(MapperParsingException.class, () -> createMapperService(topMapping(b -> {
+            b.startObject("runtime");
+            b.startObject("obj");
+            b.field("type", "composite");
+            b.startObject("script").field("source", "dummy").endObject();
+            b.startObject("fields");
+            b.startObject("long-subfield").field("type", "unsupported").endObject();
+            b.endObject();
+            b.endObject();
+            b.endObject();
+        })));
+        assertThat(e.getMessage(), containsString(""));
+    }
+
+    public void testToXContent() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {
+            b.startObject("runtime");
+            b.startObject("message");
+            b.field("type", "composite");
+            b.field("script", "dummy");
+            b.startObject("meta").field("test-meta", "value").endObject();
+            b.startObject("fields").startObject("response").field("type", "long").endObject().endObject();
+            b.endObject();
+            b.endObject();
+        }));
+        assertEquals("{\"_doc\":{\"runtime\":{" +
+            "\"message\":{\"type\":\"composite\"," +
+            "\"meta\":{\"test-meta\":\"value\"}," +
+            "\"script\":{\"source\":\"dummy\",\"lang\":\"painless\"}," +
+            "\"fields\":{\"response\":{\"type\":\"long\"}}}}}}",
+            Strings.toString(mapperService.mappingLookup().getMapping()));
+    }
+
+    public void testScriptOnSubFieldThrowsError() {
+        Exception e = expectThrows(MapperParsingException.class, () -> createMapperService(runtimeMapping(b -> {
+            b.startObject("obj");
+            b.field("type", "composite");
+            b.field("script", "dummy");
+            b.startObject("fields");
+            b.startObject("long").field("type", "long").field("script", "dummy").endObject();
+            b.endObject();
+            b.endObject();
+        })));
+
+        assertThat(e.getMessage(), containsString("Cannot use [script] parameter on sub-field [long] of composite field [obj]"));
+    }
+
+    public void testObjectWithoutScript() {
+        Exception e = expectThrows(MapperParsingException.class, () -> createMapperService(runtimeMapping(b -> {
+            b.startObject("obj");
+            b.field("type", "composite");
+            b.startObject("fields");
+            b.startObject("long").field("type", "long").endObject();
+            b.endObject();
+            b.endObject();
+        })));
+        assertThat(e.getMessage(), containsString("composite runtime field [obj] must declare a [script]"));
+    }
+
+    public void testObjectNullScript() {
+        Exception e = expectThrows(MapperParsingException.class, () -> createMapperService(runtimeMapping(b -> {
+            b.startObject("obj");
+            b.field("type", "composite");
+            b.nullField("script");
+            b.startObject("fields");
+            b.startObject("long").field("type", "long").endObject();
+            b.endObject();
+            b.endObject();
+        })));
+        assertThat(e.getMessage(), containsString(" [script] on runtime field [obj] of type [composite] must not have a [null] value"));
+
+    }
+
+    public void testObjectWithoutFields() {
+        {
+            Exception e = expectThrows(MapperParsingException.class, () -> createMapperService(runtimeMapping(b -> {
+                b.startObject("obj");
+                b.field("type", "composite");
+                b.field("script", "dummy");
+                b.endObject();
+            })));
+            assertThat(e.getMessage(), containsString("composite runtime field [obj] must declare its [fields]"));
+        }
+        {
+            Exception e = expectThrows(MapperParsingException.class, () -> createMapperService(runtimeMapping(b -> {
+                b.startObject("obj");
+                b.field("type", "composite");
+                b.field("script", "dummy");
+                b.startObject("fields").endObject();
+                b.endObject();
+            })));
+            assertThat(e.getMessage(), containsString("composite runtime field [obj] must declare its [fields]"));
+        }
+    }
+
+    public void testMappingUpdate() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {
+            b.startObject("runtime");
+            b.startObject("obj");
+            b.field("type", "composite");
+            b.startObject("script").field("source", "dummy").endObject();
+            b.startObject("fields");
+            b.startObject("long-subfield").field("type", "long").endObject();
+            b.startObject("str-subfield").field("type", "keyword").endObject();
+            b.endObject();
+            b.endObject();
+            b.endObject();
+        }));
+
+        XContentBuilder b = XContentBuilder.builder(XContentType.JSON.xContent());
+        b.startObject();
+        b.startObject("_doc");
+        b.startObject("runtime");
+        b.startObject("obj");
+        b.field("type", "composite");
+        b.startObject("script").field("source", "dummy2").endObject();
+        b.startObject("fields");
+        b.startObject("double-subfield").field("type", "double").endObject();
+        b.endObject();
+        b.endObject();
+        b.endObject();
+        b.endObject();
+        b.endObject();
+
+        merge(mapperService, b);
+
+        assertNull(mapperService.mappingLookup().getFieldType("obj.long-subfield"));
+        assertNull(mapperService.mappingLookup().getFieldType("obj.str-subfield"));
+        MappedFieldType doubleSubField = mapperService.mappingLookup().getFieldType("obj.double-subfield");
+        assertEquals("obj.double-subfield", doubleSubField.name());
+        assertEquals("double", doubleSubField.typeName());
+
+        RuntimeField rf = mapperService.mappingLookup().getMapping().getRoot().getRuntimeField("obj");
+        assertEquals("obj", rf.name());
+
+        Collection<MappedFieldType> mappedFieldTypes = rf.asMappedFieldTypes().collect(Collectors.toList());
+        assertEquals(1, mappedFieldTypes.size());
+        assertSame(doubleSubField, mappedFieldTypes.iterator().next());
+
+        assertEquals("{\"obj\":{\"type\":\"composite\"," +
+            "\"script\":{\"source\":\"dummy2\",\"lang\":\"painless\"}," +
+            "\"fields\":{\"double-subfield\":{\"type\":\"double\"}}}}", Strings.toString(rf));
+    }
+
+    public void testFieldDefinedTwiceWithSameName() throws IOException {
+        IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> createMapperService(topMapping(b -> {
+            b.startObject("runtime");
+            b.startObject("obj.long-subfield").field("type", "long").endObject();
+            b.startObject("obj");
+            b.field("type", "composite");
+            b.startObject("script").field("source", "dummy").endObject();
+            b.startObject("fields");
+            b.startObject("long-subfield").field("type", "long").endObject();
+            b.endObject();
+            b.endObject();
+            b.endObject();
+        })));
+        assertThat(e.getMessage(), containsString("Found two runtime fields with same name [obj.long-subfield]"));
+
+        MapperService mapperService = createMapperService(topMapping(b -> {
+            b.startObject("runtime");
+            b.startObject("obj.str-subfield").field("type", "long").endObject();
+            b.startObject("obj");
+            b.field("type", "composite");
+            b.startObject("script").field("source", "dummy").endObject();
+            b.startObject("fields");
+            b.startObject("long-subfield").field("type", "long").endObject();
+            b.endObject();
+            b.endObject();
+            b.endObject();
+        }));
+
+        XContentBuilder builder = XContentBuilder.builder(XContentType.JSON.xContent());
+        builder.startObject();
+        builder.startObject("_doc");
+        builder.startObject("runtime");
+        builder.startObject("obj.long-subfield").field("type", "long").endObject();
+        builder.endObject();
+        builder.endObject();
+        builder.endObject();
+        IllegalArgumentException iae = expectThrows(IllegalArgumentException.class, () -> merge(mapperService, builder));
+        assertThat(iae.getMessage(), containsString("Found two runtime fields with same name [obj.long-subfield]"));
+    }
+
+    public void testParseDocumentSubFieldAccess() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {
+            b.field("dynamic", false);
+            b.startObject("runtime");
+            b.startObject("obj");
+            b.field("type", "composite");
+            b.field("script", "split-str-long");
+            b.startObject("fields");
+            b.startObject("str").field("type", "keyword").endObject();
+            b.startObject("long").field("type", "long").endObject();
+            b.endObject();
+            b.endObject();
+            b.endObject();
+        }));
+
+        ParsedDocument doc1 = mapperService.documentMapper().parse(source(b -> b.field("field", "foo 1")));
+        ParsedDocument doc2 = mapperService.documentMapper().parse(source(b -> b.field("field", "bar 2")));
+
+        withLuceneIndex(mapperService, iw -> iw.addDocuments(Arrays.asList(doc1.rootDoc(), doc2.rootDoc())), reader -> {
+            SearchLookup searchLookup = new SearchLookup(
+                mapperService::fieldType,
+                (mft, lookupSupplier) -> mft.fielddataBuilder("test", lookupSupplier).build(null, null)
+            );
+
+            LeafSearchLookup leafSearchLookup = searchLookup.getLeafSearchLookup(reader.leaves().get(0));
+
+            leafSearchLookup.setDocument(0);
+            assertEquals("foo", leafSearchLookup.doc().get("obj.str").get(0));
+            assertEquals(1L, leafSearchLookup.doc().get("obj.long").get(0));
+
+            leafSearchLookup.setDocument(1);
+            assertEquals("bar", leafSearchLookup.doc().get("obj.str").get(0));
+            assertEquals(2L, leafSearchLookup.doc().get("obj.long").get(0));
+        });
+    }
+
+    public void testParseDocumentDynamicMapping() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {
+            b.startObject("runtime");
+            b.startObject("obj");
+            b.field("type", "composite");
+            b.field("script", "dummy");
+            b.startObject("fields");
+            b.startObject("str").field("type", "keyword").endObject();
+            b.startObject("long").field("type", "long").endObject();
+            b.endObject();
+            b.endObject();
+            b.endObject();
+        }));
+
+        ParsedDocument doc1 = mapperService.documentMapper().parse(source(b -> b.field("obj.long", 1L).field("obj.str", "value")));
+        assertNull(doc1.rootDoc().get("obj.long"));
+        assertNull(doc1.rootDoc().get("obj.str"));
+
+        assertNull(mapperService.mappingLookup().getMapper("obj.long"));
+        assertNull(mapperService.mappingLookup().getMapper("obj.str"));
+        assertNotNull(mapperService.mappingLookup().getFieldType("obj.long"));
+        assertNotNull(mapperService.mappingLookup().getFieldType("obj.str"));
+
+        XContentBuilder builder = XContentBuilder.builder(XContentType.JSON.xContent());
+        builder.startObject();
+        builder.startObject("_doc");
+        builder.startObject("properties");
+        builder.startObject("obj");
+        builder.startObject("properties");
+        builder.startObject("long").field("type", "long").endObject();
+        builder.endObject();
+        builder.endObject();
+        builder.endObject();
+        builder.endObject();
+        builder.endObject();
+        merge(mapperService, builder);
+
+        ParsedDocument doc2 = mapperService.documentMapper().parse(source(b -> b.field("obj.long", 2L)));
+        assertNotNull(doc2.rootDoc().get("obj.long"));
+        assertNull(doc2.rootDoc().get("obj.str"));
+
+        assertNotNull(mapperService.mappingLookup().getMapper("obj.long"));
+        assertNull(mapperService.mappingLookup().getMapper("obj.str"));
+        assertNotNull(mapperService.mappingLookup().getFieldType("obj.long"));
+        assertNotNull(mapperService.mappingLookup().getFieldType("obj.str"));
+    }
+
+    public void testParseDocumentSubfieldsOutsideRuntimeObject() throws IOException{
+        MapperService mapperService = createMapperService(topMapping(b -> {
+            b.startObject("runtime");
+            b.startObject("obj");
+            b.field("type", "composite");
+            b.field("script", "dummy");
+            b.startObject("fields");
+            b.startObject("long").field("type", "long").endObject();
+            b.endObject();
+            b.endObject();
+            b.endObject();
+        }));
+
+        ParsedDocument doc1 = mapperService.documentMapper().parse(source(b -> b.field("obj.long", 1L).field("obj.bool", true)));
+        assertNull(doc1.rootDoc().get("obj.long"));
+        assertNotNull(doc1.rootDoc().get("obj.bool"));
+
+        assertEquals("{\"_doc\":{\"properties\":{\"obj\":{\"properties\":{\"bool\":{\"type\":\"boolean\"}}}}}}",
+            Strings.toString(doc1.dynamicMappingsUpdate()));
+
+        MapperService mapperService2 = createMapperService(topMapping(b -> {
+            b.field("dynamic", "runtime");
+            b.startObject("runtime");
+            b.startObject("obj");
+            b.field("type", "composite");
+            b.field("script", "dummy");
+            b.startObject("fields");
+            b.startObject("long").field("type", "long").endObject();
+            b.endObject();
+            b.endObject();
+            b.endObject();
+        }));
+
+        ParsedDocument doc2 = mapperService2.documentMapper().parse(source(b -> b.field("obj.long", 1L).field("obj.bool", true)));
+        assertNull(doc2.rootDoc().get("obj.long"));
+        assertNull(doc2.rootDoc().get("obj.bool"));
+        assertEquals("{\"_doc\":{\"dynamic\":\"runtime\",\"runtime\":{\"obj.bool\":{\"type\":\"boolean\"}}}}",
+            Strings.toString(doc2.dynamicMappingsUpdate()));
+    }
+}
diff --git a/server/src/test/java/org/elasticsearch/index/mapper/DocumentParserTests.java b/server/src/test/java/org/elasticsearch/index/mapper/DocumentParserTests.java
index efd862b95a77..8c59d02ca801 100644
--- a/server/src/test/java/org/elasticsearch/index/mapper/DocumentParserTests.java
+++ b/server/src/test/java/org/elasticsearch/index/mapper/DocumentParserTests.java
@@ -23,6 +23,8 @@ import org.elasticsearch.common.xcontent.XContentParser;
 import org.elasticsearch.common.xcontent.XContentType;
 import org.elasticsearch.plugins.MapperPlugin;
 import org.elasticsearch.plugins.Plugin;
+import org.elasticsearch.script.CompositeFieldScript;
+import org.elasticsearch.search.lookup.SearchLookup;
 
 import java.io.IOException;
 import java.math.BigDecimal;
@@ -33,6 +35,7 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Function;
 
 import static org.elasticsearch.test.StreamsUtils.copyToBytesFromClasspath;
 import static org.elasticsearch.test.StreamsUtils.copyToStringFromClasspath;
@@ -1959,7 +1962,6 @@ public class DocumentParserTests extends MapperServiceTestCase {
 
     /**
      * Mapper plugin providing a mock metadata field mapper implementation that supports setting its value
-     * as well as a mock runtime field parser.
      */
     private static final class DocumentParserTestsPlugin extends Plugin implements MapperPlugin {
         /**
@@ -2001,12 +2003,22 @@ public class DocumentParserTests extends MapperServiceTestCase {
                 "test-composite",
                 new RuntimeField.Parser(n -> new RuntimeField.Builder(n) {
                     @Override
-                    protected RuntimeField createRuntimeField(MappingParserContext parserContext) {
+                    protected RuntimeField createRuntimeField(MappingParserContext parserContext)
+                    {
                         return new TestRuntimeField(n, List.of(
                             new KeywordFieldMapper.KeywordFieldType(n + ".foo"),
                             new KeywordFieldMapper.KeywordFieldType(n + ".bar")
                         ));
                     }
+
+                    @Override
+                    protected RuntimeField createChildRuntimeField(
+                        MappingParserContext parserContext,
+                        String parentName,
+                        Function<SearchLookup, CompositeFieldScript.LeafFactory> parentScriptFactory
+                    ) {
+                        throw new UnsupportedOperationException();
+                    }
                 })
             );
         }
diff --git a/server/src/test/java/org/elasticsearch/index/mapper/TestRuntimeField.java b/server/src/test/java/org/elasticsearch/index/mapper/TestRuntimeField.java
index 902d45f4cf53..15f94065bb96 100644
--- a/server/src/test/java/org/elasticsearch/index/mapper/TestRuntimeField.java
+++ b/server/src/test/java/org/elasticsearch/index/mapper/TestRuntimeField.java
@@ -15,6 +15,7 @@ import org.elasticsearch.index.query.SearchExecutionContext;
 import java.io.IOException;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.stream.Stream;
 
 public final class TestRuntimeField implements RuntimeField {
 
@@ -38,8 +39,8 @@ public final class TestRuntimeField implements RuntimeField {
     }
 
     @Override
-    public Collection<MappedFieldType> asMappedFieldTypes() {
-        return subfields;
+    public Stream<MappedFieldType> asMappedFieldTypes() {
+        return subfields.stream();
     }
 
     @Override
diff --git a/test/framework/src/main/java/org/elasticsearch/script/MockScriptEngine.java b/test/framework/src/main/java/org/elasticsearch/script/MockScriptEngine.java
index b48889603e87..390971e32e08 100644
--- a/test/framework/src/main/java/org/elasticsearch/script/MockScriptEngine.java
+++ b/test/framework/src/main/java/org/elasticsearch/script/MockScriptEngine.java
@@ -286,6 +286,15 @@ public class MockScriptEngine implements ScriptEngine {
                 }
             };
             return context.factoryClazz.cast(geoPointFieldScript);
+        } else if (context.instanceClazz.equals(CompositeFieldScript.class)) {
+            CompositeFieldScript.Factory objectFieldScript = (f, p, s) -> ctx -> new CompositeFieldScript(f, p, s, ctx) {
+                @Override
+                public void execute() {
+                    emit("field1", "value1");
+                    emit("field2", "value2");
+                }
+            };
+            return context.factoryClazz.cast(objectFieldScript);
         }
         ContextCompiler compiler = contexts.get(context);
         if (compiler != null) {