}

// OnServiceAdd is called whenever creation of new service object is observed.
func (proxier *metaProxier) OnServiceAdd(service *v1.Service) {
	proxier.ipv4Proxier.OnServiceAdd(service)
	proxier.ipv6Proxier.OnServiceAdd(service)
}

// OnServiceUpdate is called whenever modification of an existing
// service object is observed.
func (proxier *metaProxier) OnServiceUpdate(oldService, service *v1.Service) {

	i, val := 0, atomic.LoadUint64(&a)
	for ; val == 0 && i < 100; val, i = atomic.LoadUint64(&a), i+1 {
		time.Sleep(100 * time.Millisecond)
	}
	if val == 0 {
		fmt.Printf("Failed to observe atomic increment after %d tries\n", i)
	}

		{"InternalError", "/<script>", "Internal Server Error: \"/&lt;script&gt;\": ARGH\n"},
	}
	for _, test := range cases {
		observer := httptest.NewRecorder()
		fns[test.fn](observer, &http.Request{RequestURI: test.uri})
		result := observer.Body.String()
		if result != test.expected {
			t.Errorf("%s(..., %q) != %q, got %q", test.fn, test.uri, test.expected, result)
		}
	}
}

		resultLabel = noOpinionLabel
	}

	authorizationAttemptsCounter.WithContext(ctx).WithLabelValues(resultLabel).Inc()
	authorizationLatency.WithContext(ctx).WithLabelValues(resultLabel).Observe(authFinish.Sub(authStart).Seconds())
}

func recordAuthenticationMetrics(ctx context.Context, resp *authenticator.Response, ok bool, err error, apiAudiences authenticator.Audiences, authStart time.Time, authFinish time.Time) {

 * so that we instantly mark configurations as observed as their metadata is constructed. That would be an improvement
 * over this visitor, since here we only mark a configuration observed if its metadata is present in the final graph.
 * There are likely scenarios that this visitor does not cover, where a configuration's metadata is observed but
 * its component is not present in the final graph.
 */

 */
class DependencyCollectorIntegrationTest extends AbstractIntegrationSpec {
    def "cannot add dependencies after dependency set has been observed"() {
        given:
        buildFile << """
            ${createDependenciesAndConfiguration()}

            dependencies.implementation 'com:foo:1.0'

            assert conf.dependencies*.name == ["foo"]

	})
}

func RecordRequestBodySize(ctx context.Context, resource string, verb RequestBodyVerb, size int) {
	RequestBodySizes.WithContext(ctx).WithLabelValues(resource, string(verb)).Observe(float64(size))

	transformerOperationsTotal.WithLabelValues(transformationType, transformerPrefix, getErrorCode(err)).Inc()

	if err == nil {
		transformerLatencies.WithLabelValues(transformationType, transformerPrefix).Observe(elapsed.Seconds())
	}
}

// RecordCacheMiss records a miss on Key Encryption Key(KEK) - call to KMS was required to decrypt KEK.
func RecordCacheMiss() {
	envelopeTransformationCacheMissTotal.Inc()
}

    }

    /**
     * Checks if `expected` and `observed` are equal when viewed as a set and headers are
     * deduped.
     *
     * TODO: See if duped headers should be preserved on decode and verify.
     */
    private fun assertSetEquals(
      message: String,
      expected: List<Header>,
      observed: List<Header>,
    ) {
      assertThat(LinkedHashSet(observed), message)
        .isEqualTo(LinkedHashSet(expected))

		}
		dekCacheInterArrivals.WithLabelValues(transformationType).Observe(start.Sub(lastFromStorage).Seconds())
		lastFromStorage = start
	case ToStorageLabel:
		lockLastToStorage.Lock()
		defer lockLastToStorage.Unlock()

		if lastToStorage.IsZero() {
			lastToStorage = start
		}
		dekCacheInterArrivals.WithLabelValues(transformationType).Observe(start.Sub(lastToStorage).Seconds())
		lastToStorage = start
	}
}