@flyteorg/flyteidl 1.15.3 → 1.16.0-b0

package/gen/pb-js/flyteidl.d.ts

@@ -5960,6 +5960,259 @@ export namespace flyteidl {
             }
         }
 
+        /** Properties of a LogContext. */
+        interface ILogContext {
+
+            /** LogContext pods */
+            pods?: (flyteidl.core.IPodLogContext[]|null);
+
+            /** LogContext primaryPodName */
+            primaryPodName?: (string|null);
+        }
+
+        /** Represents a LogContext. */
+        class LogContext implements ILogContext {
+
+            /**
+             * Constructs a new LogContext.
+             * @param [properties] Properties to set
+             */
+            constructor(properties?: flyteidl.core.ILogContext);
+
+            /** LogContext pods. */
+            public pods: flyteidl.core.IPodLogContext[];
+
+            /** LogContext primaryPodName. */
+            public primaryPodName: string;
+
+            /**
+             * Creates a new LogContext instance using the specified properties.
+             * @param [properties] Properties to set
+             * @returns LogContext instance
+             */
+            public static create(properties?: flyteidl.core.ILogContext): flyteidl.core.LogContext;
+
+            /**
+             * Encodes the specified LogContext message. Does not implicitly {@link flyteidl.core.LogContext.verify|verify} messages.
+             * @param message LogContext message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encode(message: flyteidl.core.ILogContext, writer?: $protobuf.Writer): $protobuf.Writer;
+
+            /**
+             * Decodes a LogContext message from the specified reader or buffer.
+             * @param reader Reader or buffer to decode from
+             * @param [length] Message length if known beforehand
+             * @returns LogContext
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.LogContext;
+
+            /**
+             * Verifies a LogContext message.
+             * @param message Plain object to verify
+             * @returns `null` if valid, otherwise the reason why it is not
+             */
+            public static verify(message: { [k: string]: any }): (string|null);
+        }
+
+        /** Properties of a PodLogContext. */
+        interface IPodLogContext {
+
+            /** PodLogContext namespace */
+            namespace?: (string|null);
+
+            /** PodLogContext podName */
+            podName?: (string|null);
+
+            /** PodLogContext containers */
+            containers?: (flyteidl.core.IContainerContext[]|null);
+
+            /** PodLogContext primaryContainerName */
+            primaryContainerName?: (string|null);
+
+            /** PodLogContext initContainers */
+            initContainers?: (flyteidl.core.IContainerContext[]|null);
+        }
+
+        /** Represents a PodLogContext. */
+        class PodLogContext implements IPodLogContext {
+
+            /**
+             * Constructs a new PodLogContext.
+             * @param [properties] Properties to set
+             */
+            constructor(properties?: flyteidl.core.IPodLogContext);
+
+            /** PodLogContext namespace. */
+            public namespace: string;
+
+            /** PodLogContext podName. */
+            public podName: string;
+
+            /** PodLogContext containers. */
+            public containers: flyteidl.core.IContainerContext[];
+
+            /** PodLogContext primaryContainerName. */
+            public primaryContainerName: string;
+
+            /** PodLogContext initContainers. */
+            public initContainers: flyteidl.core.IContainerContext[];
+
+            /**
+             * Creates a new PodLogContext instance using the specified properties.
+             * @param [properties] Properties to set
+             * @returns PodLogContext instance
+             */
+            public static create(properties?: flyteidl.core.IPodLogContext): flyteidl.core.PodLogContext;
+
+            /**
+             * Encodes the specified PodLogContext message. Does not implicitly {@link flyteidl.core.PodLogContext.verify|verify} messages.
+             * @param message PodLogContext message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encode(message: flyteidl.core.IPodLogContext, writer?: $protobuf.Writer): $protobuf.Writer;
+
+            /**
+             * Decodes a PodLogContext message from the specified reader or buffer.
+             * @param reader Reader or buffer to decode from
+             * @param [length] Message length if known beforehand
+             * @returns PodLogContext
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.PodLogContext;
+
+            /**
+             * Verifies a PodLogContext message.
+             * @param message Plain object to verify
+             * @returns `null` if valid, otherwise the reason why it is not
+             */
+            public static verify(message: { [k: string]: any }): (string|null);
+        }
+
+        /** Properties of a ContainerContext. */
+        interface IContainerContext {
+
+            /** ContainerContext containerName */
+            containerName?: (string|null);
+
+            /** ContainerContext process */
+            process?: (flyteidl.core.ContainerContext.IProcessContext|null);
+        }
+
+        /** Represents a ContainerContext. */
+        class ContainerContext implements IContainerContext {
+
+            /**
+             * Constructs a new ContainerContext.
+             * @param [properties] Properties to set
+             */
+            constructor(properties?: flyteidl.core.IContainerContext);
+
+            /** ContainerContext containerName. */
+            public containerName: string;
+
+            /** ContainerContext process. */
+            public process?: (flyteidl.core.ContainerContext.IProcessContext|null);
+
+            /**
+             * Creates a new ContainerContext instance using the specified properties.
+             * @param [properties] Properties to set
+             * @returns ContainerContext instance
+             */
+            public static create(properties?: flyteidl.core.IContainerContext): flyteidl.core.ContainerContext;
+
+            /**
+             * Encodes the specified ContainerContext message. Does not implicitly {@link flyteidl.core.ContainerContext.verify|verify} messages.
+             * @param message ContainerContext message or plain object to encode
+             * @param [writer] Writer to encode to
+             * @returns Writer
+             */
+            public static encode(message: flyteidl.core.IContainerContext, writer?: $protobuf.Writer): $protobuf.Writer;
+
+            /**
+             * Decodes a ContainerContext message from the specified reader or buffer.
+             * @param reader Reader or buffer to decode from
+             * @param [length] Message length if known beforehand
+             * @returns ContainerContext
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.ContainerContext;
+
+            /**
+             * Verifies a ContainerContext message.
+             * @param message Plain object to verify
+             * @returns `null` if valid, otherwise the reason why it is not
+             */
+            public static verify(message: { [k: string]: any }): (string|null);
+        }
+
+        namespace ContainerContext {
+
+            /** Properties of a ProcessContext. */
+            interface IProcessContext {
+
+                /** ProcessContext containerStartTime */
+                containerStartTime?: (google.protobuf.ITimestamp|null);
+
+                /** ProcessContext containerEndTime */
+                containerEndTime?: (google.protobuf.ITimestamp|null);
+            }
+
+            /** Represents a ProcessContext. */
+            class ProcessContext implements IProcessContext {
+
+                /**
+                 * Constructs a new ProcessContext.
+                 * @param [properties] Properties to set
+                 */
+                constructor(properties?: flyteidl.core.ContainerContext.IProcessContext);
+
+                /** ProcessContext containerStartTime. */
+                public containerStartTime?: (google.protobuf.ITimestamp|null);
+
+                /** ProcessContext containerEndTime. */
+                public containerEndTime?: (google.protobuf.ITimestamp|null);
+
+                /**
+                 * Creates a new ProcessContext instance using the specified properties.
+                 * @param [properties] Properties to set
+                 * @returns ProcessContext instance
+                 */
+                public static create(properties?: flyteidl.core.ContainerContext.IProcessContext): flyteidl.core.ContainerContext.ProcessContext;
+
+                /**
+                 * Encodes the specified ProcessContext message. Does not implicitly {@link flyteidl.core.ContainerContext.ProcessContext.verify|verify} messages.
+                 * @param message ProcessContext message or plain object to encode
+                 * @param [writer] Writer to encode to
+                 * @returns Writer
+                 */
+                public static encode(message: flyteidl.core.ContainerContext.IProcessContext, writer?: $protobuf.Writer): $protobuf.Writer;
+
+                /**
+                 * Decodes a ProcessContext message from the specified reader or buffer.
+                 * @param reader Reader or buffer to decode from
+                 * @param [length] Message length if known beforehand
+                 * @returns ProcessContext
+                 * @throws {Error} If the payload is not a reader or valid buffer
+                 * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                 */
+                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): flyteidl.core.ContainerContext.ProcessContext;
+
+                /**
+                 * Verifies a ProcessContext message.
+                 * @param message Plain object to verify
+                 * @returns `null` if valid, otherwise the reason why it is not
+                 */
+                public static verify(message: { [k: string]: any }): (string|null);
+            }
+        }
+
         /** Properties of a QualityOfServiceSpec. */
         interface IQualityOfServiceSpec {
 
@@ -6516,6 +6769,9 @@ export namespace flyteidl {
 
             /** TaskMetadata generatesDeck */
             generatesDeck?: (google.protobuf.IBoolValue|null);
+
+            /** TaskMetadata metadata */
+            metadata?: (flyteidl.core.IK8sObjectMetadata|null);
         }
 
         /** Represents a TaskMetadata. */
@@ -6566,6 +6822,9 @@ export namespace flyteidl {
             /** TaskMetadata generatesDeck. */
             public generatesDeck?: (google.protobuf.IBoolValue|null);
 
+            /** TaskMetadata metadata. */
+            public metadata?: (flyteidl.core.IK8sObjectMetadata|null);
+
             /** TaskMetadata interruptibleValue. */
             public interruptibleValue?: "interruptible";
 
@@ -9214,6 +9473,9 @@ export namespace flyteidl {
 
             /** TaskExecutionEvent reportedAt */
             reportedAt?: (google.protobuf.ITimestamp|null);
+
+            /** TaskExecutionEvent logContext */
+            logContext?: (flyteidl.core.ILogContext|null);
         }
 
         /** Represents a TaskExecutionEvent. */
@@ -9285,6 +9547,9 @@ export namespace flyteidl {
             /** TaskExecutionEvent reportedAt. */
             public reportedAt?: (google.protobuf.ITimestamp|null);
 
+            /** TaskExecutionEvent logContext. */
+            public logContext?: (flyteidl.core.ILogContext|null);
+
             /** TaskExecutionEvent inputValue. */
             public inputValue?: ("inputUri"|"inputData");
 
@@ -9350,6 +9615,9 @@ export namespace flyteidl {
 
             /** ExternalResourceInfo customInfo */
             customInfo?: (google.protobuf.IStruct|null);
+
+            /** ExternalResourceInfo logContext */
+            logContext?: (flyteidl.core.ILogContext|null);
         }
 
         /** Represents an ExternalResourceInfo. */
@@ -9385,6 +9653,9 @@ export namespace flyteidl {
             /** ExternalResourceInfo customInfo. */
             public customInfo?: (google.protobuf.IStruct|null);
 
+            /** ExternalResourceInfo logContext. */
+            public logContext?: (flyteidl.core.ILogContext|null);
+
             /** ExternalResourceInfo targetMetadata. */
             public targetMetadata?: "workflowNodeMetadata";
 
@@ -20502,6 +20773,9 @@ export namespace flyteidl {
 
             /** TaskExecutionClosure reasons */
             reasons?: (flyteidl.admin.IReason[]|null);
+
+            /** TaskExecutionClosure logContext */
+            logContext?: (flyteidl.core.ILogContext|null);
         }
 
         /** Represents a TaskExecutionClosure. */
@@ -20558,6 +20832,9 @@ export namespace flyteidl {
             /** TaskExecutionClosure reasons. */
             public reasons: flyteidl.admin.IReason[];
 
+            /** TaskExecutionClosure logContext. */
+            public logContext?: (flyteidl.core.ILogContext|null);
+
             /** TaskExecutionClosure outputResult. */
             public outputResult?: ("outputUri"|"error"|"outputData");
 

package/gen/pb-js/flyteidl.js

@@ -14403,6 +14403,601 @@
                 return TaskLog;
             })();
     
+            core.LogContext = (function() {
+    
+                /**
+                 * Properties of a LogContext.
+                 * @memberof flyteidl.core
+                 * @interface ILogContext
+                 * @property {Array.<flyteidl.core.IPodLogContext>|null} [pods] LogContext pods
+                 * @property {string|null} [primaryPodName] LogContext primaryPodName
+                 */
+    
+                /**
+                 * Constructs a new LogContext.
+                 * @memberof flyteidl.core
+                 * @classdesc Represents a LogContext.
+                 * @implements ILogContext
+                 * @constructor
+                 * @param {flyteidl.core.ILogContext=} [properties] Properties to set
+                 */
+                function LogContext(properties) {
+                    this.pods = [];
+                    if (properties)
+                        for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                            if (properties[keys[i]] != null)
+                                this[keys[i]] = properties[keys[i]];
+                }
+    
+                /**
+                 * LogContext pods.
+                 * @member {Array.<flyteidl.core.IPodLogContext>} pods
+                 * @memberof flyteidl.core.LogContext
+                 * @instance
+                 */
+                LogContext.prototype.pods = $util.emptyArray;
+    
+                /**
+                 * LogContext primaryPodName.
+                 * @member {string} primaryPodName
+                 * @memberof flyteidl.core.LogContext
+                 * @instance
+                 */
+                LogContext.prototype.primaryPodName = "";
+    
+                /**
+                 * Creates a new LogContext instance using the specified properties.
+                 * @function create
+                 * @memberof flyteidl.core.LogContext
+                 * @static
+                 * @param {flyteidl.core.ILogContext=} [properties] Properties to set
+                 * @returns {flyteidl.core.LogContext} LogContext instance
+                 */
+                LogContext.create = function create(properties) {
+                    return new LogContext(properties);
+                };
+    
+                /**
+                 * Encodes the specified LogContext message. Does not implicitly {@link flyteidl.core.LogContext.verify|verify} messages.
+                 * @function encode
+                 * @memberof flyteidl.core.LogContext
+                 * @static
+                 * @param {flyteidl.core.ILogContext} message LogContext message or plain object to encode
+                 * @param {$protobuf.Writer} [writer] Writer to encode to
+                 * @returns {$protobuf.Writer} Writer
+                 */
+                LogContext.encode = function encode(message, writer) {
+                    if (!writer)
+                        writer = $Writer.create();
+                    if (message.pods != null && message.pods.length)
+                        for (var i = 0; i < message.pods.length; ++i)
+                            $root.flyteidl.core.PodLogContext.encode(message.pods[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+                    if (message.primaryPodName != null && message.hasOwnProperty("primaryPodName"))
+                        writer.uint32(/* id 2, wireType 2 =*/18).string(message.primaryPodName);
+                    return writer;
+                };
+    
+                /**
+                 * Decodes a LogContext message from the specified reader or buffer.
+                 * @function decode
+                 * @memberof flyteidl.core.LogContext
+                 * @static
+                 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                 * @param {number} [length] Message length if known beforehand
+                 * @returns {flyteidl.core.LogContext} LogContext
+                 * @throws {Error} If the payload is not a reader or valid buffer
+                 * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                 */
+                LogContext.decode = function decode(reader, length) {
+                    if (!(reader instanceof $Reader))
+                        reader = $Reader.create(reader);
+                    var end = length === undefined ? reader.len : reader.pos + length, message = new $root.flyteidl.core.LogContext();
+                    while (reader.pos < end) {
+                        var tag = reader.uint32();
+                        switch (tag >>> 3) {
+                        case 1:
+                            if (!(message.pods && message.pods.length))
+                                message.pods = [];
+                            message.pods.push($root.flyteidl.core.PodLogContext.decode(reader, reader.uint32()));
+                            break;
+                        case 2:
+                            message.primaryPodName = reader.string();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                    return message;
+                };
+    
+                /**
+                 * Verifies a LogContext message.
+                 * @function verify
+                 * @memberof flyteidl.core.LogContext
+                 * @static
+                 * @param {Object.<string,*>} message Plain object to verify
+                 * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                 */
+                LogContext.verify = function verify(message) {
+                    if (typeof message !== "object" || message === null)
+                        return "object expected";
+                    if (message.pods != null && message.hasOwnProperty("pods")) {
+                        if (!Array.isArray(message.pods))
+                            return "pods: array expected";
+                        for (var i = 0; i < message.pods.length; ++i) {
+                            var error = $root.flyteidl.core.PodLogContext.verify(message.pods[i]);
+                            if (error)
+                                return "pods." + error;
+                        }
+                    }
+                    if (message.primaryPodName != null && message.hasOwnProperty("primaryPodName"))
+                        if (!$util.isString(message.primaryPodName))
+                            return "primaryPodName: string expected";
+                    return null;
+                };
+    
+                return LogContext;
+            })();
+    
+            core.PodLogContext = (function() {
+    
+                /**
+                 * Properties of a PodLogContext.
+                 * @memberof flyteidl.core
+                 * @interface IPodLogContext
+                 * @property {string|null} [namespace] PodLogContext namespace
+                 * @property {string|null} [podName] PodLogContext podName
+                 * @property {Array.<flyteidl.core.IContainerContext>|null} [containers] PodLogContext containers
+                 * @property {string|null} [primaryContainerName] PodLogContext primaryContainerName
+                 * @property {Array.<flyteidl.core.IContainerContext>|null} [initContainers] PodLogContext initContainers
+                 */
+    
+                /**
+                 * Constructs a new PodLogContext.
+                 * @memberof flyteidl.core
+                 * @classdesc Represents a PodLogContext.
+                 * @implements IPodLogContext
+                 * @constructor
+                 * @param {flyteidl.core.IPodLogContext=} [properties] Properties to set
+                 */
+                function PodLogContext(properties) {
+                    this.containers = [];
+                    this.initContainers = [];
+                    if (properties)
+                        for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                            if (properties[keys[i]] != null)
+                                this[keys[i]] = properties[keys[i]];
+                }
+    
+                /**
+                 * PodLogContext namespace.
+                 * @member {string} namespace
+                 * @memberof flyteidl.core.PodLogContext
+                 * @instance
+                 */
+                PodLogContext.prototype.namespace = "";
+    
+                /**
+                 * PodLogContext podName.
+                 * @member {string} podName
+                 * @memberof flyteidl.core.PodLogContext
+                 * @instance
+                 */
+                PodLogContext.prototype.podName = "";
+    
+                /**
+                 * PodLogContext containers.
+                 * @member {Array.<flyteidl.core.IContainerContext>} containers
+                 * @memberof flyteidl.core.PodLogContext
+                 * @instance
+                 */
+                PodLogContext.prototype.containers = $util.emptyArray;
+    
+                /**
+                 * PodLogContext primaryContainerName.
+                 * @member {string} primaryContainerName
+                 * @memberof flyteidl.core.PodLogContext
+                 * @instance
+                 */
+                PodLogContext.prototype.primaryContainerName = "";
+    
+                /**
+                 * PodLogContext initContainers.
+                 * @member {Array.<flyteidl.core.IContainerContext>} initContainers
+                 * @memberof flyteidl.core.PodLogContext
+                 * @instance
+                 */
+                PodLogContext.prototype.initContainers = $util.emptyArray;
+    
+                /**
+                 * Creates a new PodLogContext instance using the specified properties.
+                 * @function create
+                 * @memberof flyteidl.core.PodLogContext
+                 * @static
+                 * @param {flyteidl.core.IPodLogContext=} [properties] Properties to set
+                 * @returns {flyteidl.core.PodLogContext} PodLogContext instance
+                 */
+                PodLogContext.create = function create(properties) {
+                    return new PodLogContext(properties);
+                };
+    
+                /**
+                 * Encodes the specified PodLogContext message. Does not implicitly {@link flyteidl.core.PodLogContext.verify|verify} messages.
+                 * @function encode
+                 * @memberof flyteidl.core.PodLogContext
+                 * @static
+                 * @param {flyteidl.core.IPodLogContext} message PodLogContext message or plain object to encode
+                 * @param {$protobuf.Writer} [writer] Writer to encode to
+                 * @returns {$protobuf.Writer} Writer
+                 */
+                PodLogContext.encode = function encode(message, writer) {
+                    if (!writer)
+                        writer = $Writer.create();
+                    if (message.namespace != null && message.hasOwnProperty("namespace"))
+                        writer.uint32(/* id 1, wireType 2 =*/10).string(message.namespace);
+                    if (message.podName != null && message.hasOwnProperty("podName"))
+                        writer.uint32(/* id 2, wireType 2 =*/18).string(message.podName);
+                    if (message.containers != null && message.containers.length)
+                        for (var i = 0; i < message.containers.length; ++i)
+                            $root.flyteidl.core.ContainerContext.encode(message.containers[i], writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();
+                    if (message.primaryContainerName != null && message.hasOwnProperty("primaryContainerName"))
+                        writer.uint32(/* id 4, wireType 2 =*/34).string(message.primaryContainerName);
+                    if (message.initContainers != null && message.initContainers.length)
+                        for (var i = 0; i < message.initContainers.length; ++i)
+                            $root.flyteidl.core.ContainerContext.encode(message.initContainers[i], writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();
+                    return writer;
+                };
+    
+                /**
+                 * Decodes a PodLogContext message from the specified reader or buffer.
+                 * @function decode
+                 * @memberof flyteidl.core.PodLogContext
+                 * @static
+                 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                 * @param {number} [length] Message length if known beforehand
+                 * @returns {flyteidl.core.PodLogContext} PodLogContext
+                 * @throws {Error} If the payload is not a reader or valid buffer
+                 * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                 */
+                PodLogContext.decode = function decode(reader, length) {
+                    if (!(reader instanceof $Reader))
+                        reader = $Reader.create(reader);
+                    var end = length === undefined ? reader.len : reader.pos + length, message = new $root.flyteidl.core.PodLogContext();
+                    while (reader.pos < end) {
+                        var tag = reader.uint32();
+                        switch (tag >>> 3) {
+                        case 1:
+                            message.namespace = reader.string();
+                            break;
+                        case 2:
+                            message.podName = reader.string();
+                            break;
+                        case 3:
+                            if (!(message.containers && message.containers.length))
+                                message.containers = [];
+                            message.containers.push($root.flyteidl.core.ContainerContext.decode(reader, reader.uint32()));
+                            break;
+                        case 4:
+                            message.primaryContainerName = reader.string();
+                            break;
+                        case 5:
+                            if (!(message.initContainers && message.initContainers.length))
+                                message.initContainers = [];
+                            message.initContainers.push($root.flyteidl.core.ContainerContext.decode(reader, reader.uint32()));
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                    return message;
+                };
+    
+                /**
+                 * Verifies a PodLogContext message.
+                 * @function verify
+                 * @memberof flyteidl.core.PodLogContext
+                 * @static
+                 * @param {Object.<string,*>} message Plain object to verify
+                 * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                 */
+                PodLogContext.verify = function verify(message) {
+                    if (typeof message !== "object" || message === null)
+                        return "object expected";
+                    if (message.namespace != null && message.hasOwnProperty("namespace"))
+                        if (!$util.isString(message.namespace))
+                            return "namespace: string expected";
+                    if (message.podName != null && message.hasOwnProperty("podName"))
+                        if (!$util.isString(message.podName))
+                            return "podName: string expected";
+                    if (message.containers != null && message.hasOwnProperty("containers")) {
+                        if (!Array.isArray(message.containers))
+                            return "containers: array expected";
+                        for (var i = 0; i < message.containers.length; ++i) {
+                            var error = $root.flyteidl.core.ContainerContext.verify(message.containers[i]);
+                            if (error)
+                                return "containers." + error;
+                        }
+                    }
+                    if (message.primaryContainerName != null && message.hasOwnProperty("primaryContainerName"))
+                        if (!$util.isString(message.primaryContainerName))
+                            return "primaryContainerName: string expected";
+                    if (message.initContainers != null && message.hasOwnProperty("initContainers")) {
+                        if (!Array.isArray(message.initContainers))
+                            return "initContainers: array expected";
+                        for (var i = 0; i < message.initContainers.length; ++i) {
+                            var error = $root.flyteidl.core.ContainerContext.verify(message.initContainers[i]);
+                            if (error)
+                                return "initContainers." + error;
+                        }
+                    }
+                    return null;
+                };
+    
+                return PodLogContext;
+            })();
+    
+            core.ContainerContext = (function() {
+    
+                /**
+                 * Properties of a ContainerContext.
+                 * @memberof flyteidl.core
+                 * @interface IContainerContext
+                 * @property {string|null} [containerName] ContainerContext containerName
+                 * @property {flyteidl.core.ContainerContext.IProcessContext|null} [process] ContainerContext process
+                 */
+    
+                /**
+                 * Constructs a new ContainerContext.
+                 * @memberof flyteidl.core
+                 * @classdesc Represents a ContainerContext.
+                 * @implements IContainerContext
+                 * @constructor
+                 * @param {flyteidl.core.IContainerContext=} [properties] Properties to set
+                 */
+                function ContainerContext(properties) {
+                    if (properties)
+                        for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                            if (properties[keys[i]] != null)
+                                this[keys[i]] = properties[keys[i]];
+                }
+    
+                /**
+                 * ContainerContext containerName.
+                 * @member {string} containerName
+                 * @memberof flyteidl.core.ContainerContext
+                 * @instance
+                 */
+                ContainerContext.prototype.containerName = "";
+    
+                /**
+                 * ContainerContext process.
+                 * @member {flyteidl.core.ContainerContext.IProcessContext|null|undefined} process
+                 * @memberof flyteidl.core.ContainerContext
+                 * @instance
+                 */
+                ContainerContext.prototype.process = null;
+    
+                /**
+                 * Creates a new ContainerContext instance using the specified properties.
+                 * @function create
+                 * @memberof flyteidl.core.ContainerContext
+                 * @static
+                 * @param {flyteidl.core.IContainerContext=} [properties] Properties to set
+                 * @returns {flyteidl.core.ContainerContext} ContainerContext instance
+                 */
+                ContainerContext.create = function create(properties) {
+                    return new ContainerContext(properties);
+                };
+    
+                /**
+                 * Encodes the specified ContainerContext message. Does not implicitly {@link flyteidl.core.ContainerContext.verify|verify} messages.
+                 * @function encode
+                 * @memberof flyteidl.core.ContainerContext
+                 * @static
+                 * @param {flyteidl.core.IContainerContext} message ContainerContext message or plain object to encode
+                 * @param {$protobuf.Writer} [writer] Writer to encode to
+                 * @returns {$protobuf.Writer} Writer
+                 */
+                ContainerContext.encode = function encode(message, writer) {
+                    if (!writer)
+                        writer = $Writer.create();
+                    if (message.containerName != null && message.hasOwnProperty("containerName"))
+                        writer.uint32(/* id 1, wireType 2 =*/10).string(message.containerName);
+                    if (message.process != null && message.hasOwnProperty("process"))
+                        $root.flyteidl.core.ContainerContext.ProcessContext.encode(message.process, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+                    return writer;
+                };
+    
+                /**
+                 * Decodes a ContainerContext message from the specified reader or buffer.
+                 * @function decode
+                 * @memberof flyteidl.core.ContainerContext
+                 * @static
+                 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                 * @param {number} [length] Message length if known beforehand
+                 * @returns {flyteidl.core.ContainerContext} ContainerContext
+                 * @throws {Error} If the payload is not a reader or valid buffer
+                 * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                 */
+                ContainerContext.decode = function decode(reader, length) {
+                    if (!(reader instanceof $Reader))
+                        reader = $Reader.create(reader);
+                    var end = length === undefined ? reader.len : reader.pos + length, message = new $root.flyteidl.core.ContainerContext();
+                    while (reader.pos < end) {
+                        var tag = reader.uint32();
+                        switch (tag >>> 3) {
+                        case 1:
+                            message.containerName = reader.string();
+                            break;
+                        case 2:
+                            message.process = $root.flyteidl.core.ContainerContext.ProcessContext.decode(reader, reader.uint32());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                    return message;
+                };
+    
+                /**
+                 * Verifies a ContainerContext message.
+                 * @function verify
+                 * @memberof flyteidl.core.ContainerContext
+                 * @static
+                 * @param {Object.<string,*>} message Plain object to verify
+                 * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                 */
+                ContainerContext.verify = function verify(message) {
+                    if (typeof message !== "object" || message === null)
+                        return "object expected";
+                    if (message.containerName != null && message.hasOwnProperty("containerName"))
+                        if (!$util.isString(message.containerName))
+                            return "containerName: string expected";
+                    if (message.process != null && message.hasOwnProperty("process")) {
+                        var error = $root.flyteidl.core.ContainerContext.ProcessContext.verify(message.process);
+                        if (error)
+                            return "process." + error;
+                    }
+                    return null;
+                };
+    
+                ContainerContext.ProcessContext = (function() {
+    
+                    /**
+                     * Properties of a ProcessContext.
+                     * @memberof flyteidl.core.ContainerContext
+                     * @interface IProcessContext
+                     * @property {google.protobuf.ITimestamp|null} [containerStartTime] ProcessContext containerStartTime
+                     * @property {google.protobuf.ITimestamp|null} [containerEndTime] ProcessContext containerEndTime
+                     */
+    
+                    /**
+                     * Constructs a new ProcessContext.
+                     * @memberof flyteidl.core.ContainerContext
+                     * @classdesc Represents a ProcessContext.
+                     * @implements IProcessContext
+                     * @constructor
+                     * @param {flyteidl.core.ContainerContext.IProcessContext=} [properties] Properties to set
+                     */
+                    function ProcessContext(properties) {
+                        if (properties)
+                            for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                if (properties[keys[i]] != null)
+                                    this[keys[i]] = properties[keys[i]];
+                    }
+    
+                    /**
+                     * ProcessContext containerStartTime.
+                     * @member {google.protobuf.ITimestamp|null|undefined} containerStartTime
+                     * @memberof flyteidl.core.ContainerContext.ProcessContext
+                     * @instance
+                     */
+                    ProcessContext.prototype.containerStartTime = null;
+    
+                    /**
+                     * ProcessContext containerEndTime.
+                     * @member {google.protobuf.ITimestamp|null|undefined} containerEndTime
+                     * @memberof flyteidl.core.ContainerContext.ProcessContext
+                     * @instance
+                     */
+                    ProcessContext.prototype.containerEndTime = null;
+    
+                    /**
+                     * Creates a new ProcessContext instance using the specified properties.
+                     * @function create
+                     * @memberof flyteidl.core.ContainerContext.ProcessContext
+                     * @static
+                     * @param {flyteidl.core.ContainerContext.IProcessContext=} [properties] Properties to set
+                     * @returns {flyteidl.core.ContainerContext.ProcessContext} ProcessContext instance
+                     */
+                    ProcessContext.create = function create(properties) {
+                        return new ProcessContext(properties);
+                    };
+    
+                    /**
+                     * Encodes the specified ProcessContext message. Does not implicitly {@link flyteidl.core.ContainerContext.ProcessContext.verify|verify} messages.
+                     * @function encode
+                     * @memberof flyteidl.core.ContainerContext.ProcessContext
+                     * @static
+                     * @param {flyteidl.core.ContainerContext.IProcessContext} message ProcessContext message or plain object to encode
+                     * @param {$protobuf.Writer} [writer] Writer to encode to
+                     * @returns {$protobuf.Writer} Writer
+                     */
+                    ProcessContext.encode = function encode(message, writer) {
+                        if (!writer)
+                            writer = $Writer.create();
+                        if (message.containerStartTime != null && message.hasOwnProperty("containerStartTime"))
+                            $root.google.protobuf.Timestamp.encode(message.containerStartTime, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+                        if (message.containerEndTime != null && message.hasOwnProperty("containerEndTime"))
+                            $root.google.protobuf.Timestamp.encode(message.containerEndTime, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+                        return writer;
+                    };
+    
+                    /**
+                     * Decodes a ProcessContext message from the specified reader or buffer.
+                     * @function decode
+                     * @memberof flyteidl.core.ContainerContext.ProcessContext
+                     * @static
+                     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                     * @param {number} [length] Message length if known beforehand
+                     * @returns {flyteidl.core.ContainerContext.ProcessContext} ProcessContext
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    ProcessContext.decode = function decode(reader, length) {
+                        if (!(reader instanceof $Reader))
+                            reader = $Reader.create(reader);
+                        var end = length === undefined ? reader.len : reader.pos + length, message = new $root.flyteidl.core.ContainerContext.ProcessContext();
+                        while (reader.pos < end) {
+                            var tag = reader.uint32();
+                            switch (tag >>> 3) {
+                            case 1:
+                                message.containerStartTime = $root.google.protobuf.Timestamp.decode(reader, reader.uint32());
+                                break;
+                            case 2:
+                                message.containerEndTime = $root.google.protobuf.Timestamp.decode(reader, reader.uint32());
+                                break;
+                            default:
+                                reader.skipType(tag & 7);
+                                break;
+                            }
+                        }
+                        return message;
+                    };
+    
+                    /**
+                     * Verifies a ProcessContext message.
+                     * @function verify
+                     * @memberof flyteidl.core.ContainerContext.ProcessContext
+                     * @static
+                     * @param {Object.<string,*>} message Plain object to verify
+                     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                     */
+                    ProcessContext.verify = function verify(message) {
+                        if (typeof message !== "object" || message === null)
+                            return "object expected";
+                        if (message.containerStartTime != null && message.hasOwnProperty("containerStartTime")) {
+                            var error = $root.google.protobuf.Timestamp.verify(message.containerStartTime);
+                            if (error)
+                                return "containerStartTime." + error;
+                        }
+                        if (message.containerEndTime != null && message.hasOwnProperty("containerEndTime")) {
+                            var error = $root.google.protobuf.Timestamp.verify(message.containerEndTime);
+                            if (error)
+                                return "containerEndTime." + error;
+                        }
+                        return null;
+                    };
+    
+                    return ProcessContext;
+                })();
+    
+                return ContainerContext;
+            })();
+    
             core.QualityOfServiceSpec = (function() {
     
                 /**
@@ -15618,6 +16213,7 @@
                  * @property {Array.<string>|null} [cacheIgnoreInputVars] TaskMetadata cacheIgnoreInputVars
                  * @property {boolean|null} [isEager] TaskMetadata isEager
                  * @property {google.protobuf.IBoolValue|null} [generatesDeck] TaskMetadata generatesDeck
+                 * @property {flyteidl.core.IK8sObjectMetadata|null} [metadata] TaskMetadata metadata
                  */
     
                 /**
@@ -15741,6 +16337,14 @@
                  */
                 TaskMetadata.prototype.generatesDeck = null;
     
+                /**
+                 * TaskMetadata metadata.
+                 * @member {flyteidl.core.IK8sObjectMetadata|null|undefined} metadata
+                 * @memberof flyteidl.core.TaskMetadata
+                 * @instance
+                 */
+                TaskMetadata.prototype.metadata = null;
+    
                 // OneOf field names bound to virtual getters and setters
                 var $oneOfFields;
     
@@ -15807,6 +16411,8 @@
                         writer.uint32(/* id 14, wireType 0 =*/112).bool(message.isEager);
                     if (message.generatesDeck != null && message.hasOwnProperty("generatesDeck"))
                         $root.google.protobuf.BoolValue.encode(message.generatesDeck, writer.uint32(/* id 15, wireType 2 =*/122).fork()).ldelim();
+                    if (message.metadata != null && message.hasOwnProperty("metadata"))
+                        $root.flyteidl.core.K8sObjectMetadata.encode(message.metadata, writer.uint32(/* id 16, wireType 2 =*/130).fork()).ldelim();
                     return writer;
                 };
     
@@ -15874,6 +16480,9 @@
                         case 15:
                             message.generatesDeck = $root.google.protobuf.BoolValue.decode(reader, reader.uint32());
                             break;
+                        case 16:
+                            message.metadata = $root.flyteidl.core.K8sObjectMetadata.decode(reader, reader.uint32());
+                            break;
                         default:
                             reader.skipType(tag & 7);
                             break;
@@ -15952,6 +16561,11 @@
                         if (error)
                             return "generatesDeck." + error;
                     }
+                    if (message.metadata != null && message.hasOwnProperty("metadata")) {
+                        var error = $root.flyteidl.core.K8sObjectMetadata.verify(message.metadata);
+                        if (error)
+                            return "metadata." + error;
+                    }
                     return null;
                 };
     
@@ -22476,6 +23090,7 @@
                  * @property {flyteidl.event.ITaskExecutionMetadata|null} [metadata] TaskExecutionEvent metadata
                  * @property {number|null} [eventVersion] TaskExecutionEvent eventVersion
                  * @property {google.protobuf.ITimestamp|null} [reportedAt] TaskExecutionEvent reportedAt
+                 * @property {flyteidl.core.ILogContext|null} [logContext] TaskExecutionEvent logContext
                  */
     
                 /**
@@ -22655,6 +23270,14 @@
                  */
                 TaskExecutionEvent.prototype.reportedAt = null;
     
+                /**
+                 * TaskExecutionEvent logContext.
+                 * @member {flyteidl.core.ILogContext|null|undefined} logContext
+                 * @memberof flyteidl.event.TaskExecutionEvent
+                 * @instance
+                 */
+                TaskExecutionEvent.prototype.logContext = null;
+    
                 // OneOf field names bound to virtual getters and setters
                 var $oneOfFields;
     
@@ -22746,6 +23369,8 @@
                     if (message.reasons != null && message.reasons.length)
                         for (var i = 0; i < message.reasons.length; ++i)
                             $root.flyteidl.event.EventReason.encode(message.reasons[i], writer.uint32(/* id 21, wireType 2 =*/170).fork()).ldelim();
+                    if (message.logContext != null && message.hasOwnProperty("logContext"))
+                        $root.flyteidl.core.LogContext.encode(message.logContext, writer.uint32(/* id 22, wireType 2 =*/178).fork()).ldelim();
                     return writer;
                 };
     
@@ -22831,6 +23456,9 @@
                         case 20:
                             message.reportedAt = $root.google.protobuf.Timestamp.decode(reader, reader.uint32());
                             break;
+                        case 22:
+                            message.logContext = $root.flyteidl.core.LogContext.decode(reader, reader.uint32());
+                            break;
                         default:
                             reader.skipType(tag & 7);
                             break;
@@ -22971,6 +23599,11 @@
                         if (error)
                             return "reportedAt." + error;
                     }
+                    if (message.logContext != null && message.hasOwnProperty("logContext")) {
+                        var error = $root.flyteidl.core.LogContext.verify(message.logContext);
+                        if (error)
+                            return "logContext." + error;
+                    }
                     return null;
                 };
     
@@ -22991,6 +23624,7 @@
                  * @property {Array.<flyteidl.core.ITaskLog>|null} [logs] ExternalResourceInfo logs
                  * @property {flyteidl.event.IWorkflowNodeMetadata|null} [workflowNodeMetadata] ExternalResourceInfo workflowNodeMetadata
                  * @property {google.protobuf.IStruct|null} [customInfo] ExternalResourceInfo customInfo
+                 * @property {flyteidl.core.ILogContext|null} [logContext] ExternalResourceInfo logContext
                  */
     
                 /**
@@ -23073,6 +23707,14 @@
                  */
                 ExternalResourceInfo.prototype.customInfo = null;
     
+                /**
+                 * ExternalResourceInfo logContext.
+                 * @member {flyteidl.core.ILogContext|null|undefined} logContext
+                 * @memberof flyteidl.event.ExternalResourceInfo
+                 * @instance
+                 */
+                ExternalResourceInfo.prototype.logContext = null;
+    
                 // OneOf field names bound to virtual getters and setters
                 var $oneOfFields;
     
@@ -23128,6 +23770,8 @@
                         $root.flyteidl.event.WorkflowNodeMetadata.encode(message.workflowNodeMetadata, writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim();
                     if (message.customInfo != null && message.hasOwnProperty("customInfo"))
                         $root.google.protobuf.Struct.encode(message.customInfo, writer.uint32(/* id 8, wireType 2 =*/66).fork()).ldelim();
+                    if (message.logContext != null && message.hasOwnProperty("logContext"))
+                        $root.flyteidl.core.LogContext.encode(message.logContext, writer.uint32(/* id 9, wireType 2 =*/74).fork()).ldelim();
                     return writer;
                 };
     
@@ -23175,6 +23819,9 @@
                         case 8:
                             message.customInfo = $root.google.protobuf.Struct.decode(reader, reader.uint32());
                             break;
+                        case 9:
+                            message.logContext = $root.flyteidl.core.LogContext.decode(reader, reader.uint32());
+                            break;
                         default:
                             reader.skipType(tag & 7);
                             break;
@@ -23254,6 +23901,11 @@
                         if (error)
                             return "customInfo." + error;
                     }
+                    if (message.logContext != null && message.hasOwnProperty("logContext")) {
+                        var error = $root.flyteidl.core.LogContext.verify(message.logContext);
+                        if (error)
+                            return "logContext." + error;
+                    }
                     return null;
                 };
     
@@ -49348,6 +50000,7 @@
                  * @property {flyteidl.event.ITaskExecutionMetadata|null} [metadata] TaskExecutionClosure metadata
                  * @property {number|null} [eventVersion] TaskExecutionClosure eventVersion
                  * @property {Array.<flyteidl.admin.IReason>|null} [reasons] TaskExecutionClosure reasons
+                 * @property {flyteidl.core.ILogContext|null} [logContext] TaskExecutionClosure logContext
                  */
     
                 /**
@@ -49487,6 +50140,14 @@
                  */
                 TaskExecutionClosure.prototype.reasons = $util.emptyArray;
     
+                /**
+                 * TaskExecutionClosure logContext.
+                 * @member {flyteidl.core.ILogContext|null|undefined} logContext
+                 * @memberof flyteidl.admin.TaskExecutionClosure
+                 * @instance
+                 */
+                TaskExecutionClosure.prototype.logContext = null;
+    
                 // OneOf field names bound to virtual getters and setters
                 var $oneOfFields;
     
@@ -49557,6 +50218,8 @@
                     if (message.reasons != null && message.reasons.length)
                         for (var i = 0; i < message.reasons.length; ++i)
                             $root.flyteidl.admin.Reason.encode(message.reasons[i], writer.uint32(/* id 18, wireType 2 =*/146).fork()).ldelim();
+                    if (message.logContext != null && message.hasOwnProperty("logContext"))
+                        $root.flyteidl.core.LogContext.encode(message.logContext, writer.uint32(/* id 19, wireType 2 =*/154).fork()).ldelim();
                     return writer;
                 };
     
@@ -49627,6 +50290,9 @@
                                 message.reasons = [];
                             message.reasons.push($root.flyteidl.admin.Reason.decode(reader, reader.uint32()));
                             break;
+                        case 19:
+                            message.logContext = $root.flyteidl.core.LogContext.decode(reader, reader.uint32());
+                            break;
                         default:
                             reader.skipType(tag & 7);
                             break;
@@ -49743,6 +50409,11 @@
                                 return "reasons." + error;
                         }
                     }
+                    if (message.logContext != null && message.hasOwnProperty("logContext")) {
+                        var error = $root.flyteidl.core.LogContext.verify(message.logContext);
+                        if (error)
+                            return "logContext." + error;
+                    }
                     return null;
                 };
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flyteorg/flyteidl",
-  "version": "1.15.3",
+  "version": "1.16.0b0",
   "description": "Compiled protocol buffers and gRPC service clients/servers for Flyte IDLs",
   "repository": {
     "type": "git",

package/protos/flyteidl/admin/task_execution.proto

@@ -127,6 +127,9 @@ message TaskExecutionClosure {
     // A time-series of the phase transition or update explanations. This, when compared to storing a singular reason
     // as previously done, is much more valuable in visualizing and understanding historical evaluations.
     repeated Reason reasons = 18;
+
+    // Contains metadata required to identify logs related to this task execution
+    core.LogContext log_context = 19;
 }
 
 // Reason is a single message annotated with a timestamp to indicate the instant the reason occurred.

package/protos/flyteidl/core/execution.proto

@@ -98,6 +98,38 @@ message TaskLog {
     bool HideOnceFinished = 6;
 }
 
+// Contains metadata required to identify logs produces by a set of pods
+message LogContext {
+    repeated PodLogContext pods = 1;
+    string primary_pod_name = 2;
+}
+
+// Contains metadata required to identify logs produces by a single pod
+message PodLogContext {
+    string namespace = 1;
+
+    string pod_name = 2;
+
+    repeated ContainerContext containers = 3;
+
+    string primary_container_name = 4;
+
+    repeated ContainerContext init_containers = 5;
+}
+
+// Contains metadata required to identify logs produces by a single container
+message ContainerContext {
+    string container_name = 1;
+
+    // Contains metadata required to identify logs produces by a single light-weight process that was run inside a container
+    message ProcessContext {
+        google.protobuf.Timestamp container_start_time = 1;
+        google.protobuf.Timestamp container_end_time = 2;
+    }
+
+    ProcessContext process = 2;
+}
+
 // Represents customized execution run-time attributes.
 message QualityOfServiceSpec {
     // Indicates how much queueing delay an execution can tolerate.

package/protos/flyteidl/core/tasks.proto

@@ -159,6 +159,16 @@ message TaskMetadata {
     // - true: The task will generate a deck.
     // - false: The task will not generate a deck.
     google.protobuf.BoolValue generates_deck = 15;
+
+    // Metadata applied to task pods or task CR objects.
+    // In flytekit, labels and annotations resulting in this metadata field
+    // are provided via `@task(labels=..., annotations=...)`.
+    // For tasks backed by pods like PythonFunctionTask, these take precedence
+    // over the metadata provided via `@task(pod_template=PodTemplate(labels=...))` which are transported
+    // in the K8sPod message. For tasks backed by CRDs, this metadata is applied to
+    // the CR object itself while the metadata in the pod template/K8sPod is applied
+    // to the pod template spec of the CR object.
+    K8sObjectMetadata metadata = 16;
 }
 
 // A Task structure that uniquely identifies a task in the system

package/protos/flyteidl/event/event.proto

@@ -263,6 +263,9 @@ message TaskExecutionEvent {
     // but this event will not be reported until the pod is marked as completed. Extracting both of these timestamps
     // facilitates a more accurate portrayal of the evaluation time-series. 
     google.protobuf.Timestamp reported_at = 20;
+
+    // Contains metadata required to identify logs related to this task execution
+    core.LogContext log_context = 22;
 }
 
 // This message contains metadata about external resources produced or used by a specific task execution.
@@ -297,6 +300,9 @@ message ExternalResourceInfo {
 
     // Extensible field for custom, plugin-specific info
     google.protobuf.Struct custom_info = 8;
+
+    // Contains metadata required to identify logs related to this task execution
+    core.LogContext log_context = 9;
 }