// gce_node_exporter
discovery.gce "node_exporter_a" {
	project = "meesho-demand-prd-0622"
	zone    = "asia-southeast1-a"
	port    = 9100
}
discovery.gce "node_exporter_b" {
	project = "meesho-demand-prd-0622"
	zone    = "asia-southeast1-b"
	port    = 9100
}
discovery.gce "node_exporter_c" {
	project = "meesho-demand-prd-0622"
	zone    = "asia-southeast1-c"
	port    = 9100
}
discovery.relabel "node_exporter_gce" {
	targets = concat(
      discovery.gce.node_exporter_a.targets,
      discovery.gce.node_exporter_b.targets,
      discovery.gce.node_exporter_c.targets,
    )

	rule {
		source_labels = ["__meta_gce_instance_status"]
		regex         = "RUNNING"
		action        = "keep"
	}
  	rule {
		source_labels = ["__meta_gce_label_goog-k8s-cluster-name"]
		regex         = "k8s"
		action        = "drop"
	}
	rule {
		source_labels = ["__meta_gce_label_monitoring"]
		regex         = "no"
		action        = "drop"
	}
	rule {
		source_labels = ["__meta_gce_instance_name"]
		regex         = "gke-k8s-.*"
		action        = "drop"
	}
	rule {
		target_label = "project"
		replacement  = "meesho-demand-prd-0622"
	}
	rule {
		source_labels = ["__meta_gce_instance_name"]
		target_label  = "name"
	}
	rule {
		source_labels = ["__meta_gce_instance_id"]
		target_label  = "instance_id"
	}
	rule {
		source_labels = ["__meta_gce_instance_status"]
		target_label  = "status"
	}
	rule {
		source_labels = ["__meta_gce_private_ip"]
		target_label  = "private_ip"
	}
	rule {
		source_labels = ["__meta_gce_public_ip"]
		target_label  = "public_ip"
	}
	rule {
		source_labels = ["__meta_gce_label_bu"]
		target_label  = "bu"
	}
	rule {
		source_labels = ["__meta_gce_label_component"]
		target_label  = "component"
	}
	rule {
		source_labels = ["__meta_gce_label_env"]
		target_label  = "env"
	}
	rule {
		source_labels = ["__meta_gce_label_service"]
		target_label  = "service"
	}
	rule {
		source_labels = ["__meta_gce_label_team"]
		target_label  = "team"
	}
	rule {
		source_labels = ["__meta_gce_label_type"]
		target_label  = "type"
	}
	rule {
		source_labels = ["__meta_gce_label_alerts"]
		target_label  = "alerts"
	}
}
prometheus.scrape "node_exporter_gce" {
	targets        = discovery.relabel.node_exporter_gce.output
	forward_to     = [prometheus.remote_write.mimir.receiver]
	job_name       = "node_exporter_gce"
	clustering {
    	enabled = true
  	}
}

// kube state metrics
discovery.relabel "kube_state_metrics_pod" {
  	targets = [{__address__ = "kube-state-metrics-demand-prd.kube-system.svc.cluster.local:8080",}]

  	rule {
		regex  = "__meta_kubernetes_node_label_(.+)"
		action = "labelmap"
	}
  	rule {
		target_label = "cluster"
		replacement  = "k8s-demand-prd-ase1"
  	}
}
prometheus.scrape "kube_state_metrics_pod" {
	targets        = discovery.relabel.kube_state_metrics_pod.output
	forward_to     = [prometheus.remote_write.mimir.receiver]
	job_name       = "kube_state_metrics_pod"
	scrape_interval = "15s"
	clustering {
		enabled = true
	}
}

// cadvisor metrics
discovery.kubernetes "kubernetes_nodes" {
  	role = "node"
}
discovery.relabel "cadvisor_kubernetes_nodes" {
	targets = discovery.kubernetes.kubernetes_nodes.targets

	rule {
		replacement  = "k8s-demand-prd-ase1"
		target_label = "cluster"
	}
	rule {
		regex  = "__meta_kubernetes_node_label_(.+)"
		action = "labelmap"
	}
	rule {
		replacement  = "kubernetes.default.svc:443"
		target_label = "__address__"
	}
	rule {
		source_labels = ["__meta_kubernetes_node_name"]
		regex         = "(.+)"
		target_label  = "__metrics_path__"
		replacement   = "/api/v1/nodes/$1/proxy/metrics/cadvisor"
	}
}
prometheus.scrape "cadvisor_kubernetes_nodes" {
	targets    = discovery.relabel.cadvisor_kubernetes_nodes.output
	forward_to = [prometheus.remote_write.mimir.receiver]
	job_name   = "cadvisor_kubernetes_nodes"
	scheme     = "https"
	scrape_interval = "15s"
	authorization {
		type             = "Bearer"
		credentials_file = "/var/run/secrets/kubernetes.io/serviceaccount/token"
	}
	tls_config {
		ca_file              = "/var/run/secrets/kubernetes.io/serviceaccount/ca.crt"
		insecure_skip_verify = true
	}
	clustering {
		enabled = true
	}
}

// kubelet
discovery.relabel "kubelet_kubernetes_nodes" {
	targets = discovery.kubernetes.kubernetes_nodes.targets
	
	rule {
		replacement  = "k8s-demand-prd-ase1"
		target_label = "cluster"
	}
	rule {
		regex  = "__meta_kubernetes_node_label_(.+)"
		action = "labelmap"
	}
	rule {
		target_label = "__address__"
		replacement  = "kubernetes.default.svc:443"
	}
	rule {
		source_labels = ["__meta_kubernetes_node_name"]
		regex         = "(.+)"
		target_label  = "__metrics_path__"
		replacement   = "/api/v1/nodes/$1/proxy/metrics"
	}
}
prometheus.scrape "kubelet_kubernetes_nodes" {
	targets    = discovery.relabel.kubelet_kubernetes_nodes.output
	forward_to = [prometheus.remote_write.mimir.receiver]
	job_name   = "kubelet_kubernetes_nodes"
	scheme     = "https"
	scrape_interval = "15s"
	authorization {
		type             = "Bearer"
		credentials_file = "/var/run/secrets/kubernetes.io/serviceaccount/token"
	}
	tls_config {
		ca_file              = "/var/run/secrets/kubernetes.io/serviceaccount/ca.crt"
		insecure_skip_verify = true
	}
	clustering {
		enabled = true
	}
}

// prometheus_kubernetes_endpoints
discovery.kubernetes "kubernetes_endpoints" {
  	role = "endpoints"
}
discovery.relabel "prometheus_kubernetes_endpoints" {
    targets = discovery.kubernetes.kubernetes_endpoints.targets

    rule {
		source_labels = ["__meta_kubernetes_pod_container_init"]
		regex         = "true"
		action        = "drop"
    }
    rule {
		source_labels = ["__meta_kubernetes_service_annotation_prometheus_io_port"]
		target_label = "__meta_kubernetes_pod_container_port_number"
		action = "keepequal"
    }
    rule {
		source_labels = ["__meta_kubernetes_service_annotation_prometheus_io_scrape"]
		regex         = "true"
		action        = "keep"
    }
    rule {
		source_labels = ["__meta_kubernetes_service_annotation_prometheus_io_path"]
		regex         = "(.+)"
		target_label  = "__metrics_path__"
    }
    rule {
		source_labels = ["__address__", "__meta_kubernetes_service_annotation_prometheus_io_port"]
		regex         = "([^:]+)(?::\\d+)?;(\\d+)"
		target_label  = "__address__"
		replacement   = "$1:$2"
    }
    rule {
		regex  = "__meta_kubernetes_node_label_(.+)"
		action = "labelmap"
	}
    rule {
		regex  = "__meta_kubernetes_service_label_(.+)"
		action = "labelmap"
    }
    rule {
		source_labels = ["__meta_kubernetes_namespace"]
		target_label  = "kubernetes_namespace"
    }
    rule {
		source_labels = ["__meta_kubernetes_endpoint_node_name"]
		target_label  = "kubernetes_node"
    }
    rule {
		source_labels = ["__meta_kubernetes_service_name"]
		target_label  = "kubernetes_service_name"
    }
    rule {
		source_labels = ["__meta_kubernetes_endpoints_name"]
		target_label  = "kubernetes_endpoints_name"
	}
    rule {
		source_labels = ["__meta_kubernetes_pod_name"]
		target_label  = "kubernetes_pod_name"
    }
    rule {
		target_label = "cluster"
		replacement  = "k8s-demand-prd-ase1"
	}
}
prometheus.scrape "prometheus_kubernetes_endpoints" {
	targets        = discovery.relabel.prometheus_kubernetes_endpoints.output
	forward_to     = [prometheus.remote_write.mimir.receiver]
	job_name       = "prometheus_kubernetes_endpoints"
	clustering {
		enabled = true
	}
}

// prometheus_kubernetes_pods
discovery.kubernetes "kubernetes_pods" {
	role = "pod"
}
discovery.relabel "prometheus_kubernetes_pods" {
	targets = discovery.kubernetes.kubernetes_pods.targets

	rule {
		source_labels = ["__meta_kubernetes_pod_container_init"]
		regex         = "true"
		action        = "drop"
	}
	rule {
		source_labels = ["__meta_kubernetes_pod_annotation_prometheus_io_port"]
		target_label = "__meta_kubernetes_pod_container_port_number"
		action = "keepequal"
	}
	rule {
		source_labels = ["__meta_kubernetes_pod_annotation_prometheus_io_scrape"]
		regex         = "true"
		action        = "keep"
	}
	rule {
		source_labels = ["__meta_kubernetes_pod_annotation_prometheus_io_path"]
		regex         = "(.+)"
		target_label  = "__metrics_path__"
	}
	rule {
		source_labels = ["__address__", "__meta_kubernetes_pod_annotation_prometheus_io_port"]
		regex         = "([^:]+)(?::\\d+)?;(\\d+)"
		target_label  = "__address__"
		replacement   = "$1:$2"
	}
	rule {
		regex  = "__meta_kubernetes_node_label_(.+)"
		action = "labelmap"
	}
	rule {
		regex  = "__meta_kubernetes_pod_label_(.+)"
		action = "labelmap"
	}
	rule {
		source_labels = ["__meta_kubernetes_namespace"]
		target_label  = "kubernetes_namespace"
	}
	rule {
		source_labels = ["__meta_kubernetes_pod_node_name"]
		target_label  = "kubernetes_node"
	}
	rule {
		source_labels = ["__meta_kubernetes_pod_name"]
		target_label  = "kubernetes_pod_name"
	}
	rule {
		target_label = "cluster"
		replacement  = "k8s-demand-prd-ase1"
	}
}
prometheus.scrape "prometheus_kubernetes_pods" {
	targets    = discovery.relabel.prometheus_kubernetes_pods.output
	forward_to = [prometheus.remote_write.mimir.receiver]
	job_name   = "prometheus_kubernetes_pods"
  	clustering {
    	enabled = true
  	}
}

// jmx_kubernetes_pods
discovery.relabel "jmx_kubernetes_pods" {
	targets = discovery.kubernetes.kubernetes_pods.targets

	rule {
		source_labels = ["__meta_kubernetes_pod_container_init"]
		regex         = "true"
		action        = "drop"
	}
	rule {
		source_labels = ["__meta_kubernetes_pod_annotation_jmx_io_port"]
		target_label = "__meta_kubernetes_pod_container_port_number"
		action = "keepequal"
	}
	rule {
		source_labels = ["__meta_kubernetes_pod_annotation_jmx_io_scrape"]
		regex         = "true"
		action        = "keep"
	}
	rule {
		source_labels = ["__meta_kubernetes_pod_annotation_jmx_io_path"]
		regex         = "(.+)"
		target_label  = "__metrics_path__"
	}
	rule {
		source_labels = ["__address__", "__meta_kubernetes_pod_annotation_jmx_io_port"]
		regex         = "([^:]+)(?::\\d+)?;(\\d+)"
		target_label  = "__address__"
		replacement   = "$1:$2"
	}
	rule {
		regex  = "__meta_kubernetes_node_label_(.+)"
		action = "labelmap"
	}
  	rule {
		regex  = "__meta_kubernetes_pod_label_(.+)"
		action = "labelmap"
	}
	rule {
		source_labels = ["__meta_kubernetes_namespace"]
		target_label  = "kubernetes_namespace"
	}
	rule {
		source_labels = ["__meta_kubernetes_pod_node_name"]
		target_label  = "kubernetes_node"
	}
	rule {
		source_labels = ["__meta_kubernetes_pod_name"]
		target_label  = "kubernetes_pod_name"
	}
	rule {
		target_label = "cluster"
		replacement  = "k8s-demand-prd-ase1"
	}
}
prometheus.scrape "jmx_kubernetes_pods" {
	targets    = discovery.relabel.jmx_kubernetes_pods.output
	forward_to = [prometheus.remote_write.mimir.receiver]
	job_name   = "jmx_kubernetes_pods"
  	clustering {
    	enabled = true
  	}
}

// scylladb_manager_exporter
discovery.gce "scylladb_manager_a" {
	project = "meesho-demand-prd-0622"
	zone    = "asia-southeast1-a"
	port    = 5090
}
discovery.gce "scylladb_manager_b" {
	project = "meesho-demand-prd-0622"
	zone    = "asia-southeast1-b"
	port    = 5090
}
discovery.gce "scylladb_manager_c" {
	project = "meesho-demand-prd-0622"
	zone    = "asia-southeast1-c"
	port    = 5090
}
discovery.relabel "scylladb_manager_gce" {
	targets = concat(
    discovery.gce.scylladb_manager_a.targets,
    discovery.gce.scylladb_manager_b.targets,
    discovery.gce.scylladb_manager_c.targets,)

	rule {
		source_labels = ["__meta_gce_label_component"]
		regex         = "scyl"
		action        = "keep"
	}
	rule {
		source_labels = ["__meta_gce_label_bu"]
		target_label  = "bu"
	}
	rule {
		source_labels = ["__meta_gce_label_team"]
		target_label  = "team"
	}
	rule {
		source_labels = ["__meta_gce_label_service"]
		target_label  = "service"
	}
	rule {
		source_labels = ["__meta_gce_label_type"]
		target_label  = "type"
	}
	rule {
		source_labels = ["__meta_gce_label_env"]
		target_label  = "env"
	}
	rule {
		source_labels = ["__meta_gce_label_cluster"]
		target_label  = "cluster"
	}
	rule {
		source_labels = ["__meta_gce_instance_name"]
		target_label  = "name"
	}
	rule {
		source_labels = ["__meta_gce_label_priority"]
		target_label  = "priority"
	}
}
prometheus.scrape "scylladb_manager_gce" {
	targets    = discovery.relabel.scylladb_manager_gce.output
	forward_to = [prometheus.remote_write.mimir.receiver]
	job_name   = "scylladb_manager_gce"
	clustering {
		enabled = true
	}
}

// scylladb_exporter
discovery.gce "scylladb_a" {
	project = "meesho-demand-prd-0622"
	zone    = "asia-southeast1-a"
	port    = 9180
}
discovery.gce "scylladb_b" {
	project = "meesho-demand-prd-0622"
	zone    = "asia-southeast1-b"
	port    = 9180
}
discovery.gce "scylladb_c" {
	project = "meesho-demand-prd-0622"
	zone    = "asia-southeast1-c"
	port    = 9180
}
discovery.relabel "scylladb_gce" {
	targets = concat(
    discovery.gce.scylladb_a.targets,
    discovery.gce.scylladb_b.targets,
    discovery.gce.scylladb_c.targets,)

	rule {
		source_labels = ["__meta_gce_label_component"]
		regex         = "scyl"
		action        = "keep"
	}
	rule {
		source_labels = ["__meta_gce_label_bu"]
		target_label  = "bu"
	}
	rule {
		source_labels = ["__meta_gce_label_team"]
		target_label  = "team"
	}
	rule {
		source_labels = ["__meta_gce_label_service"]
		target_label  = "service"
	}
	rule {
		source_labels = ["__meta_gce_label_type"]
		target_label  = "type"
	}
	rule {
		source_labels = ["__meta_gce_label_env"]
		target_label  = "env"
	}
	rule {
		source_labels = ["__meta_gce_label_cluster"]
		target_label  = "cluster"
	}
	rule {
		source_labels = ["__meta_gce_instance_name"]
		target_label  = "name"
	}
	rule {
		source_labels = ["__meta_gce_label_priority"]
		target_label  = "priority"
	}
}
prometheus.scrape "scylladb_gce" {
	targets    = discovery.relabel.scylladb_gce.output
	forward_to = [prometheus.relabel.scylladb_gce.receiver]
	job_name   = "scylladb_gce"
	clustering {
		enabled = true
	}
}
prometheus.relabel "scylladb_gce" {
	forward_to = [prometheus.remote_write.mimir.receiver]

	rule {
		source_labels = ["__name__", "scheduling_group_name"]
		regex         = "(scylla_storage_proxy_coordinator_.*_bucket;)(atexit|gossip|mem_compaction|memtable|streaming|background_reclaim|compaction|main|memtable_to_cache)"
		action        = "drop"
	}
	rule {
		source_labels = ["version"]
		regex         = "(.+)"
		target_label  = "CPU"
		replacement   = "cpu"
	}
	rule {
		source_labels = ["version"]
		regex         = "(.+)"
		target_label  = "CQL"
		replacement   = "cql"
	}
	rule {
		source_labels = ["version"]
		regex         = "(.+)"
		target_label  = "OS"
		replacement   = "os"
	}
	rule {
		source_labels = ["version"]
		regex         = "(.+)"
		target_label  = "IO"
		replacement   = "io"
	}
	rule {
		source_labels = ["version"]
		regex         = "(.+)"
		target_label  = "Errors"
		replacement   = "errors"
	}
	rule {
		regex  = "help|exported_instance"
		action = "labeldrop"
	}
	rule {
		source_labels = ["version"]
		regex         = "([0-9]+\\.[0-9]+)(\\.?[0-9]*).*"
		target_label  = "svr"
		replacement   = "$1$2"
	}
	rule {
		source_labels = ["__name__", "quantile"]
		regex         = "(scylla_storage_proxy_coordinator_write_latency_summary;0.990*)"
		target_label  = "__name__"
		replacement   = "wlatencyp99"
	}
	rule {
		source_labels = ["__name__", "quantile"]
		regex         = "(scylla_storage_proxy_coordinator_write_latency_summary;0.950*)"
		target_label  = "__name__"
		replacement   = "wlatencyp95"
	}
	rule {
		source_labels = ["__name__", "quantile"]
		regex         = "(scylla_storage_proxy_coordinator_write_latency_summary;0.50*)"
		target_label  = "__name__"
		replacement   = "wlatencya"
	}
	rule {
		source_labels = ["__name__", "quantile"]
		regex         = "(scylla_storage_proxy_coordinator_read_latency_summary;0.990*)"
		target_label  = "__name__"
		replacement   = "rlatencyp99"
	}
	rule {
		source_labels = ["__name__", "quantile"]
		regex         = "(scylla_storage_proxy_coordinator_read_latency_summary;0.950*)"
		target_label  = "__name__"
		replacement   = "rlatencyp95"
	}
	rule {
		source_labels = ["__name__", "quantile"]
		regex         = "(scylla_storage_proxy_coordinator_read_latency_summary;0.50*)"
		target_label  = "__name__"
		replacement   = "rlatencya"
	}
	rule {
		source_labels = ["__name__", "quantile"]
		regex         = "(scylla_storage_proxy_coordinator_cas_write_latency_summary;0.950*)"
		target_label  = "__name__"
		replacement   = "caswlatencyp95"
	}
	rule {
		source_labels = ["__name__", "quantile"]
		regex         = "(scylla_storage_proxy_coordinator_cas_write_latency_summary;0.990*)"
		target_label  = "__name__"
		replacement   = "caswlatencyp99"
	}
	rule {
		source_labels = ["__name__", "quantile"]
		regex         = "(scylla_storage_proxy_coordinator_cas_write_latency_summary;0.50*)"
		target_label  = "__name__"
		replacement   = "caswlatencya"
	}
	rule {
		source_labels = ["__name__", "quantile"]
		regex         = "(scylla_storage_proxy_coordinator_cas_read_latency_summary;0.950*)"
		target_label  = "__name__"
		replacement   = "casrlatencyp95"
	}
	rule {
		source_labels = ["__name__", "quantile"]
		regex         = "(scylla_storage_proxy_coordinator_cas_read_latency_summary;0.990*)"
		target_label  = "__name__"
		replacement   = "casrlatencyp99"
	}
	rule {
		source_labels = ["__name__", "quantile"]
		regex         = "(scylla_storage_proxy_coordinator_cas_read_latency_summary;0.50*)"
		target_label  = "__name__"
		replacement   = "casrlatencya"
	}
	rule {
		source_labels = ["__name__"]
		regex         = "(.latency..?.?|cas.latency..?.?)"
		target_label  = "by"
		replacement   = "instance,shard"
	}
	rule {
		source_labels = ["__name__"]
		regex         = "(scylla_storage_proxy_coordinator_read_timeouts|scylla_reactor_utilization|scylla_storage_proxy_coordinator_read_timeouts|scylla_storage_proxy_coordinator_read_unavailable|scylla_storage_proxy_coordinator_write_timeouts|scylla_storage_proxy_coordinator_write_unavailable|.latency..?.?)"
		target_label  = "level"
		replacement   = "2"
	}
	rule {
		source_labels = ["__name__"]
		regex         = "(scylla_storage_proxy_coordinator_read_timeouts|scylla_reactor_utilization|scylla_storage_proxy_coordinator_read_timeouts|scylla_storage_proxy_coordinator_read_unavailable|scylla_storage_proxy_coordinator_write_timeouts|scylla_storage_proxy_coordinator_write_unavailable|.latency..?.?)"
		target_label  = "dd"
		replacement   = "2"
	}
	rule {
		source_labels = ["__name__"]
		regex         = "(scylla_node_operation_mode)"
		target_label  = "level"
		replacement   = "1"
	}
	rule {
		source_labels = ["__name__"]
		regex         = "(scylla_node_operation_mode)"
		target_label  = "dd"
		replacement   = "1"
	}
	rule {
		source_labels = ["scheduling_group_name"]
		regex         = "(atexit|gossip|mem_compaction|memtable|streaming|background_reclaim|compaction|main|memtable_to_cache)"
		target_label  = "level"
		replacement   = ""
	}
	rule {
		source_labels = ["scheduling_group_name"]
		regex         = "(atexit|gossip|mem_compaction|memtable|streaming|background_reclaim|compaction|main|memtable_to_cache)"
		target_label  = "dd"
		replacement   = ""
	}
}

// zookeeper
discovery.gce "zookeeper_a" {
	project = "meesho-demand-prd-0622"
	zone    = "asia-southeast1-a"
	port    = 7000
}
discovery.gce "zookeeper_b" {
	project = "meesho-demand-prd-0622"
	zone    = "asia-southeast1-b"
	port    = 7000
}
discovery.gce "zookeeper_c" {
	project = "meesho-demand-prd-0622"
	zone    = "asia-southeast1-c"
	port    = 7000
}
discovery.relabel "zookeeper_gce" {
	targets = concat(
		discovery.gce.zookeeper_a.targets,
		discovery.gce.zookeeper_b.targets,
		discovery.gce.zookeeper_c.targets,
	)
	rule {
		source_labels = ["__meta_gce_label_service"]
		regex         = "(comms-zookeeper)"
		action        = "keep"
	}
	rule {
		target_label = "component"
		replacement  = "zookeeper"
	}
	rule {
		target_label = "priority"
		replacement  = "p0"
	}
	rule {
		target_label = "project"
		replacement  = "meesho-demand-prd-0622"
	}
	rule {
		source_labels = ["__meta_gce_label_bu"]
		target_label  = "bu"
	}
	rule {
		source_labels = ["__meta_gce_label_team"]
		target_label  = "team"
	}
	rule {
		source_labels = ["__meta_gce_label_service"]
		target_label  = "app"
	}
	rule {
		source_labels = ["__meta_gce_label_type"]
		target_label  = "type"
	}
	rule {
		source_labels = ["__meta_gce_label_env"]
		target_label  = "env"
	}
	rule {
		source_labels = ["__meta_gce_instance_name"]
		target_label  = "name"
	}
}
prometheus.scrape "zookeeper_gce" {
	targets    = discovery.relabel.zookeeper_gce.output
	forward_to = [prometheus.remote_write.mimir.receiver]
	job_name   = "zookeeper_gce"
	clustering {
    	enabled = true
  	}
}

// Flink
discovery.gce "flink01_b" {
	project = "meesho-demand-prd-0622"
	zone    = "asia-southeast1-b"
	port    = 19900
}
discovery.gce "flink02_b" {
	project = "meesho-demand-prd-0622"
	zone    = "asia-southeast1-b"
	port    = 19901
}
discovery.gce "flink03_b" {
	project = "meesho-demand-prd-0622"
	zone    = "asia-southeast1-b"
	port    = 19902
}
discovery.gce "flink04_b" {
	project = "meesho-demand-prd-0622"
	zone    = "asia-southeast1-b"
	port    = 19903
}
discovery.gce "flink05_b" {
	project = "meesho-demand-prd-0622"
	zone    = "asia-southeast1-b"
	port    = 19904
}
discovery.relabel "flink_gce" {
	targets = concat(discovery.gce.flink01_b.targets,
		discovery.gce.flink02_b.targets,
		discovery.gce.flink03_b.targets,
		discovery.gce.flink04_b.targets,
		discovery.gce.flink05_b.targets,
	)
	rule {
		source_labels = ["__meta_gce_instance_status"]
		regex         = "RUNNING"
		action        = "keep"
	}
	rule {
		source_labels = ["__meta_gce_label_service"]
		regex         = "(marvel-flink)"
		action        = "keep"
	}
	rule {
		source_labels = ["__meta_gce_label_application"]
		regex         = "(hadoop)"
		action        = "keep"
	}
}
prometheus.scrape "flink_gce" {
	targets	= discovery.relabel.flink_gce.output
	forward_to      = [prometheus.remote_write.mimir.receiver]
	job_name        = "flink_gce"
	scrape_interval = "30s"
	scrape_timeout  = "30s"
	metrics_path    = "/"
	clustering {
    	enabled = true
  	}
}

// msearch
discovery.gce "msearch_gce" {
	project = "meesho-demand-prd-0622"
	zone    = "asia-southeast1-a"
	port    = 9273
}
discovery.relabel "msearch_gce" {
	targets = discovery.gce.msearch_gce.targets
	rule {
		source_labels = ["__meta_gce_label_team"]
		regex         = "(discovery-platform|search)"
		action        = "keep"
	}
}
prometheus.scrape "msearch_gce" {
	targets         = discovery.relabel.msearch_gce.output
	forward_to      = [prometheus.remote_write.mimir.receiver]
	job_name        = "msearch_gce"
	scrape_interval = "30s"
	scrape_timeout  = "30s"
	clustering {
    	enabled = true
  	}
}

prometheus.exporter.self "default" {}
prometheus.scrape "alloy_pods" {
  	targets    = prometheus.exporter.self.default.targets
  	forward_to = [prometheus.remote_write.mimir.receiver]
}

// recivers
otelcol.receiver.otlp "otlp_receiver" {
	grpc {
		endpoint = "0.0.0.0:4317"
	}
	http {
		endpoint = "0.0.0.0:4318"
	}
	output {
		metrics = [otelcol.processor.k8sattributes.add_metadata.input]
		logs    = [otelcol.processor.filter.error_warn_logs.input, otelcol.processor.filter.info_logs.input]
		traces  = [otelcol.processor.k8sattributes.add_metadata.input]
	}
}

// processors
otelcol.processor.filter "error_warn_logs" {
	error_mode = "ignore"
	logs {
		log_record = ["severity_number < SEVERITY_NUMBER_WARN",]
	}
	output {
		logs    = [otelcol.processor.k8sattributes.add_metadata.input]
	}
}
otelcol.processor.filter "info_logs" {
	error_mode = "ignore"
	logs {
		log_record = ["severity_number >= SEVERITY_NUMBER_WARN",]
	}
	output {
		logs    = [otelcol.processor.probabilistic_sampler.log_sampler.input]
	}
}
otelcol.processor.probabilistic_sampler "log_sampler" {
	sampling_percentage = 1
	output {
		logs = [otelcol.processor.k8sattributes.add_metadata.input]
	}
}
otelcol.processor.k8sattributes "add_metadata" {
  	extract {
		label {
			from = "pod"
			key_regex = "(.*)"
			tag_name  = "$1"
		}
		metadata = [
			"k8s.namespace.name",
			"k8s.deployment.name",
			"k8s.statefulset.name",
			"k8s.daemonset.name",
			"k8s.cronjob.name",
			"k8s.job.name",
			"k8s.node.name",
			"k8s.pod.name",
		]
  	}
  	output {
		metrics = [otelcol.processor.transform.add_kube_attrs.input]
		logs    = [otelcol.processor.transform.add_kube_attrs.input]
		traces  = [otelcol.processor.transform.add_kube_attrs.input]
  	}
}
otelcol.processor.transform "add_kube_attrs" {
  	error_mode = "ignore"
  	metric_statements {
		context = "datapoint"
		statements = [
			"set(attributes[\"k8s_namespace_name\"], resource.attributes[\"k8s.namespace.name\"])",
			"set(attributes[\"k8s_deployment_name\"], resource.attributes[\"k8s.deployment.name\"])",
			"set(attributes[\"k8s_statefulset_name\"], resource.attributes[\"k8s.statefulset.name\"])",
			"set(attributes[\"k8s_daemonset_name\"], resource.attributes[\"k8s.daemonset.name\"])",
			"set(attributes[\"k8s_cronjob_name\"], resource.attributes[\"k8s.cronjob.name\"])",
			"set(attributes[\"k8s_job_name\"], resource.attributes[\"k8s.job.name\"])",
			"set(attributes[\"k8s_node_name\"], resource.attributes[\"k8s.node.name\"])",
			"set(attributes[\"k8s_pod_name\"], resource.attributes[\"k8s.pod.name\"])",
			"set(attributes[\"cluster\"], \"k8s-demand-prd-ase1\")",
			"set(attributes[\"env\"], resource.attributes[\"env\"])",
			"set(attributes[\"bu\"], resource.attributes[\"bu\"])",
			"set(attributes[\"team\"], resource.attributes[\"team\"])",
			"set(attributes[\"version\"], resource.attributes[\"version\"])",
			"set(attributes[\"job\"], \"otel_agent_push\")",
		]
  	}
	log_statements {
		context = "log"
		statements = [
			"set(attributes[\"k8s_namespace_name\"], resource.attributes[\"k8s.namespace.name\"])",
			"set(attributes[\"k8s_deployment_name\"], resource.attributes[\"k8s.deployment.name\"])",
			"set(attributes[\"k8s_statefulset_name\"], resource.attributes[\"k8s.statefulset.name\"])",
			"set(attributes[\"k8s_daemonset_name\"], resource.attributes[\"k8s.daemonset.name\"])",
			"set(attributes[\"k8s_cronjob_name\"], resource.attributes[\"k8s.cronjob.name\"])",
			"set(attributes[\"k8s_job_name\"], resource.attributes[\"k8s.job.name\"])",
			"set(attributes[\"k8s_node_name\"], resource.attributes[\"k8s.node.name\"])",
			"set(attributes[\"k8s_pod_name\"], resource.attributes[\"k8s.pod.name\"])",
			"set(attributes[\"cluster\"], \"k8s-demand-prd-ase1\")",
			"set(attributes[\"env\"], resource.attributes[\"env\"])",
			"set(attributes[\"bu\"], resource.attributes[\"bu\"])",
			"set(attributes[\"team\"], resource.attributes[\"team\"])",
			"set(attributes[\"version\"], resource.attributes[\"version\"])",
			"set(attributes[\"job\"], \"otel_agent_push\")",
		]
	}
	trace_statements {
		context = "span"
		statements = [
			"set(attributes[\"k8s_namespace_name\"], resource.attributes[\"k8s.namespace.name\"])",
			"set(attributes[\"k8s_deployment_name\"], resource.attributes[\"k8s.deployment.name\"])",
			"set(attributes[\"k8s_statefulset_name\"], resource.attributes[\"k8s.statefulset.name\"])",
			"set(attributes[\"k8s_daemonset_name\"], resource.attributes[\"k8s.daemonset.name\"])",
			"set(attributes[\"k8s_cronjob_name\"], resource.attributes[\"k8s.cronjob.name\"])",
			"set(attributes[\"k8s_job_name\"], resource.attributes[\"k8s.job.name\"])",
			"set(attributes[\"k8s_node_name\"], resource.attributes[\"k8s.node.name\"])",
			"set(attributes[\"k8s_pod_name\"], resource.attributes[\"k8s.pod.name\"])",
			"set(attributes[\"cluster\"], \"k8s-demand-prd-ase1\")",
			"set(attributes[\"env\"], resource.attributes[\"env\"])",
			"set(attributes[\"bu\"], resource.attributes[\"bu\"])",
			"set(attributes[\"team\"], resource.attributes[\"team\"])",
			"set(attributes[\"version\"], resource.attributes[\"version\"])",
			"set(attributes[\"job\"], \"otel_agent_push\")",
		]
	}
	output {
		metrics = [otelcol.processor.batch.otlp_batcher.input]
		logs    = [otelcol.processor.batch.otlp_batcher.input]
		traces  = [otelcol.exporter.loadbalancing.otel.input]
	}
}
otelcol.processor.batch "otlp_batcher" {
	output {
		metrics = [otelcol.exporter.otlphttp.mimir.input]
		logs    = [otelcol.exporter.otlphttp.loki.input]
	}
}

// writers
prometheus.remote_write "mimir" {
	endpoint {
		url = "http://mimir-nginx.mimir-distributed.svc.clusterset.local/api/v1/push"
		headers = {"X-Scope-OrgID" = "anonymous"}
		tls_config {
			insecure_skip_verify = true
		}
		queue_config {
			min_shards = 25
		}
	}
}
otelcol.exporter.otlphttp "mimir" {
	client {
		endpoint = "http://mimir-nginx.mimir-distributed.svc.clusterset.local/otlp"
		headers = {"X-Scope-OrgID" = "anonymous"}
		tls {
			insecure = true
		}
	}
}
otelcol.exporter.otlphttp "loki" {
	client {
		endpoint = "http://loki-gateway.loki-distributed.svc.clusterset.local/otlp"
		tls {
			insecure = true
		}
	}
}
otelcol.exporter.otlp "tempo" {
	client {
		endpoint = "tempo-distributor.tempo-distributed.svc.clusterset.local:4317"
		tls {
			insecure = true
		}
	}
}
otelcol.exporter.loadbalancing "otel" {
    routing_key = "traceID"
	resolver {
        dns {
            hostname = "opentelemetry-statefulset-headless.opentelemetry.svc.clusterset.local"
            timeout  = "5s"
        }
    }
    protocol {
        otlp {
            client {
				tls {
					insecure = true
				}
			}
			queue {
				num_consumers = 100
				queue_size = 100000
			}
        }
    }
}