cleanup

Author: jack-berg

sdk/common/src/test/java/io/opentelemetry/sdk/internal/AttributesMapTest.java

@@ -16,8 +16,8 @@ class AttributesMapTest {
   @Test
   void asMap() {
     AttributesMap attributesMap = AttributesMap.create(2, Integer.MAX_VALUE);
-    attributesMap.putIfCapacity(longKey("one"), 1L);
-    attributesMap.putIfCapacity(longKey("two"), 2L);
+    attributesMap.put(longKey("one"), 1L);
+    attributesMap.put(longKey("two"), 2L);
 
     assertThat(attributesMap.asMap())
         .containsOnly(entry(longKey("one"), 1L), entry(longKey("two"), 2L));

sdk/logs/src/main/java/io/opentelemetry/sdk/logs/ExtendedSdkLogRecordBuilder.java

@@ -115,7 +115,7 @@ public <T> ExtendedSdkLogRecordBuilder setAttribute(ExtendedAttributeKey<T> key,
           ExtendedAttributesMap.create(
               logLimits.getMaxNumberOfAttributes(), logLimits.getMaxAttributeValueLength());
     }
-    this.extendedAttributes.putIfCapacity(key, value);
+    this.extendedAttributes.put(key, value);
     return this;
   }
 

sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLogRecordBuilder.java

@@ -111,7 +111,7 @@ public <T> SdkLogRecordBuilder setAttribute(AttributeKey<T> key, @Nullable T val
           AttributesMap.create(
               logLimits.getMaxNumberOfAttributes(), logLimits.getMaxAttributeValueLength());
     }
-    this.attributes.putIfCapacity(key, value);
+    this.attributes.put(key, value);
     return this;
   }
 

sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkReadWriteLogRecord.java

@@ -100,7 +100,7 @@ public <T> ReadWriteLogRecord setAttribute(AttributeKey<T> key, T value) {
             AttributesMap.create(
                 logLimits.getMaxNumberOfAttributes(), logLimits.getMaxAttributeValueLength());
       }
-      attributes.putIfCapacity(key, value);
+      attributes.put(key, value);
     }
     return this;
   }

sdk/logs/src/test/java/io/opentelemetry/sdk/logs/ReadWriteLogRecordTest.java

@@ -51,8 +51,8 @@ void allHandlesEmpty() {
   SdkReadWriteLogRecord buildLogRecord() {
     Value<?> body = Value.of("bod");
     AttributesMap initialAttributes = AttributesMap.create(100, 200);
-    initialAttributes.putIfCapacity(stringKey("foo"), "aaiosjfjioasdiojfjioasojifja");
-    initialAttributes.putIfCapacity(stringKey("untouched"), "yes");
+    initialAttributes.put(stringKey("foo"), "aaiosjfjioasdiojfjioasojifja");
+    initialAttributes.put(stringKey("untouched"), "yes");
     LogLimits limits = LogLimits.getDefault();
     Resource resource = Resource.empty();
     InstrumentationScopeInfo scope = InstrumentationScopeInfo.create("test");

sdk/trace/src/main/java/io/opentelemetry/sdk/trace/SdkSpan.java

@@ -336,7 +336,7 @@ public <T> ReadWriteSpan setAttribute(AttributeKey<T> key, @Nullable T value) {
                 spanLimits.getMaxNumberOfAttributes(), spanLimits.getMaxAttributeValueLength());
       }
 
-      attributes.putIfCapacity(key, value);
+      attributes.put(key, value);
     }
     return this;
   }
@@ -464,7 +464,6 @@ public ReadWriteSpan recordException(Throwable exception) {
   }
 
   @Override
-  @SuppressWarnings("unchecked")
   public ReadWriteSpan recordException(Throwable exception, Attributes additionalAttributes) {
     if (exception == null) {
       return this;

sdk/trace/src/test/java/io/opentelemetry/sdk/trace/SdkSpanTest.java

@@ -445,7 +445,7 @@ void getAttribute() {
   void getAttributes() {
     SdkSpan span = createTestSpanWithAttributes(attributes);
     try {
-      Assertions.assertThat(span.getAttributes())
+      assertThat(span.getAttributes())
           .isEqualTo(
               Attributes.builder()
                   .put("MyBooleanAttributeKey", false)
@@ -461,7 +461,7 @@ void getAttributes() {
   void getAttributes_Empty() {
     SdkSpan span = createTestSpan(SpanKind.INTERNAL);
     try {
-      Assertions.assertThat(span.getAttributes()).isEqualTo(Attributes.empty());
+      assertThat(span.getAttributes()).isEqualTo(Attributes.empty());
     } finally {
       span.end();
     }
@@ -795,48 +795,48 @@ void addEvent() {
     }
     List<EventData> events = span.toSpanData().getEvents();
     assertThat(events).hasSize(6);
-    Assertions.assertThat(events.get(0))
+    assertThat(events.get(0))
         .satisfies(
             event -> {
               assertThat(event.getName()).isEqualTo("event1");
-              Assertions.assertThat(event.getAttributes()).isEqualTo(Attributes.empty());
+              assertThat(event.getAttributes()).isEqualTo(Attributes.empty());
               assertThat(event.getEpochNanos()).isEqualTo(START_EPOCH_NANOS);
             });
-    Assertions.assertThat(events.get(1))
+    assertThat(events.get(1))
         .satisfies(
             event -> {
               assertThat(event.getName()).isEqualTo("event2");
-              Assertions.assertThat(event.getAttributes())
+              assertThat(event.getAttributes())
                   .isEqualTo(Attributes.of(stringKey("e1key"), "e1Value"));
               assertThat(event.getEpochNanos()).isEqualTo(START_EPOCH_NANOS);
             });
-    Assertions.assertThat(events.get(2))
+    assertThat(events.get(2))
         .satisfies(
             event -> {
               assertThat(event.getName()).isEqualTo("event3");
-              Assertions.assertThat(event.getAttributes()).isEqualTo(Attributes.empty());
+              assertThat(event.getAttributes()).isEqualTo(Attributes.empty());
               assertThat(event.getEpochNanos()).isEqualTo(TimeUnit.SECONDS.toNanos(10));
             });
-    Assertions.assertThat(events.get(3))
+    assertThat(events.get(3))
         .satisfies(
             event -> {
               assertThat(event.getName()).isEqualTo("event4");
-              Assertions.assertThat(event.getAttributes()).isEqualTo(Attributes.empty());
+              assertThat(event.getAttributes()).isEqualTo(Attributes.empty());
               assertThat(event.getEpochNanos()).isEqualTo(TimeUnit.SECONDS.toNanos(20));
             });
-    Assertions.assertThat(events.get(4))
+    assertThat(events.get(4))
         .satisfies(
             event -> {
               assertThat(event.getName()).isEqualTo("event5");
-              Assertions.assertThat(event.getAttributes())
+              assertThat(event.getAttributes())
                   .isEqualTo(Attributes.builder().put("foo", "bar").build());
               assertThat(event.getEpochNanos()).isEqualTo(TimeUnit.MILLISECONDS.toNanos(30));
             });
-    Assertions.assertThat(events.get(5))
+    assertThat(events.get(5))
         .satisfies(
             event -> {
               assertThat(event.getName()).isEqualTo("event6");
-              Assertions.assertThat(event.getAttributes())
+              assertThat(event.getAttributes())
                   .isEqualTo(Attributes.builder().put("foo", "bar").build());
               assertThat(event.getEpochNanos()).isEqualTo(TimeUnit.MILLISECONDS.toNanos(1000));
             });
@@ -986,11 +986,11 @@ void addLink() {
           .satisfiesExactly(
               link -> {
                 assertThat(link.getSpanContext()).isEqualTo(span1.getSpanContext());
-                Assertions.assertThat(link.getAttributes()).isEqualTo(Attributes.empty());
+                assertThat(link.getAttributes()).isEqualTo(Attributes.empty());
               },
               link -> {
                 assertThat(link.getSpanContext()).isEqualTo(span2.getSpanContext());
-                Assertions.assertThat(link.getAttributes())
+                assertThat(link.getAttributes())
                     .isEqualTo(
                         Attributes.builder()
                             .put("key1", true)
@@ -1143,7 +1143,7 @@ void droppingEvents() {
         EventData expectedEvent =
             EventData.create(
                 START_EPOCH_NANOS + i * NANOS_PER_SECOND, "event2", Attributes.empty(), 0);
-        Assertions.assertThat(spanData.getEvents().get(i)).isEqualTo(expectedEvent);
+        assertThat(spanData.getEvents().get(i)).isEqualTo(expectedEvent);
         assertThat(spanData.getTotalRecordedEvents()).isEqualTo(2 * maxNumberOfEvents);
       }
     } finally {
@@ -1155,7 +1155,7 @@ void droppingEvents() {
       EventData expectedEvent =
           EventData.create(
               START_EPOCH_NANOS + i * NANOS_PER_SECOND, "event2", Attributes.empty(), 0);
-      Assertions.assertThat(spanData.getEvents().get(i)).isEqualTo(expectedEvent);
+      assertThat(spanData.getEvents().get(i)).isEqualTo(expectedEvent);
     }
   }
 
@@ -1187,7 +1187,7 @@ void recordException() {
         .isEqualTo(exception.getClass().getName());
     assertThat(event.getAttributes().get(stringKey("exception.stacktrace"))).isEqualTo(stacktrace);
     assertThat(event.getAttributes().size()).isEqualTo(3);
-    Assertions.assertThat(event)
+    assertThat(event)
         .isInstanceOfSatisfying(
             ExceptionEventData.class,
             exceptionEvent -> {
@@ -1275,7 +1275,7 @@ void recordException_additionalAttributes() {
     assertThat(event.getAttributes().get(stringKey("exception.stacktrace"))).isEqualTo(stacktrace);
     assertThat(event.getAttributes().size()).isEqualTo(4);
 
-    Assertions.assertThat(event)
+    assertThat(event)
         .isInstanceOfSatisfying(
             ExceptionEventData.class,
             exceptionEvent -> {
@@ -1458,7 +1458,7 @@ private SdkSpan createTestSpanWithAttributes(Map<AttributeKey, Object> attribute
     AttributesMap attributesMap =
         AttributesMap.create(
             spanLimits.getMaxNumberOfAttributes(), spanLimits.getMaxAttributeValueLength());
-    attributes.forEach(attributesMap::putIfCapacity);
+    attributes.forEach(attributesMap::put);
     return createTestSpan(
         SpanKind.INTERNAL,
         SpanLimits.getDefault(),