metadata:
  name: loki
  namespace: istio-system
  labels:
    helm.sh/chart: loki-6.6.3
    app.kubernetes.io/name: loki
    app.kubernetes.io/instance: loki
    app.kubernetes.io/version: "3.0.0"
    app.kubernetes.io/managed-by: Helm
automountServiceAccountToken: true
---
# Source: loki/templates/config.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: loki
  namespace: istio-system
  labels:
    helm.sh/chart: loki-6.6.3

 * limitations under the License.
 */

plugins {
    id("gradlebuild.distribution.implementation-java")
    id("gradlebuild.publish-public-libraries")
}

description = "Tools to work with managed executors"

gradlebuildJava.usedInWorkers()

dependencies {
    api(libs.jsr305)
    api(projects.stdlibJavaExtensions)

    implementation(libs.slf4jApi)

          Count of XDS connection terminations.
          This will typically spike every 30min for each instance.
        |||
      ),
      panels.timeSeries.base('Workload Manager', queries.workloadManager, |||
        Count of active and pending proxies managed by each instance.
        Pending is expected to converge to zero.
      |||
      ),
    ]),
  ], panelHeight=8)
)

import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Documents that the type or method is referenced by the build scan plugin,
 * and therefore changes need to be carefully managed. Other plugins like the
 * test-retry or the test-distribution plugin clarify their usage in the {@link #value}.
 * property.
 *
 * @since 4.0
 */
@Retention(RetentionPolicy.SOURCE)

helm.sh/chart: {{ include "gateway.chart" . }}
{{ include "gateway.selectorLabels" . }}
app.kubernetes.io/name: {{ include "gateway.name" . }}
app.kubernetes.io/version: {{ .Chart.AppVersion | quote }}
app.kubernetes.io/managed-by: {{ .Release.Service }}
{{- range $key, $val := .Values.labels }}
{{- if and (ne $key "app") (ne $key "istio") }}
{{ $key | quote }}: {{ $val | quote }}
{{- end }}
{{- end }}
{{- end }}

        |||
      ),
      panels.heatmap.base(
        'Push Time', queries.pushTime, |||
          Count of active and pending proxies managed by each instance.
          Pending is expected to converge to zero.
        |||
      ),
      panels.heatmap.bytes(
        'Push Size', queries.pushSize, |||
          Size of each xDS push.
        |||

    static JvmOptions inferJvmOptions(FileCollectionFactory fileCollectionFactory, List<String> arguments) {
        // Try to infer the effective jvm options for the currently running process.
        // We only care about 'managed' jvm args, anything else is unimportant to the running build
        JvmOptions jvmOptions = new JvmOptions(fileCollectionFactory);

        val targets = multiResolve(false).mapNotNull { it.element }
        val adjustedImportTargets = importResults.mapNotNull { it.element }
        val manager = importDirective.manager
        if (adjustedImportTargets.any { importTarget ->
                targets.any { target ->
                    manager.areElementsEquivalent(target, importTarget) ||
                            target.isConstructorOf(importTarget) ||

    id("gradlebuild.kotlin-dsl-sam-with-receiver")
    id("gradlebuild.kotlin-experimental-contracts")
}

description = "Efficient and extensible serialization for object graphs, with the capability to isolate and manage portions of the graph independently"

dependencies {
    api(projects.configurationProblemsBase)
    api(projects.stdlibJavaExtensions)
    api(projects.loggingApi)
    api(projects.serialization)

    excludePatterns.add("org/gradle/model/internal/inspect/**")
    excludePatterns.add("org/gradle/api/internal/tasks/**")
    excludePatterns.add("org/gradle/model/internal/manage/schema/**")
    excludePatterns.add("org/gradle/model/internal/type/**")
    excludePatterns.add("org/gradle/api/internal/plugins/*")
    // cycle between org.gradle.api.internal.provider and org.gradle.util.internal