chore(java): Full java 17 only support #2107
Conversation
…using Instant clocks and sql conversions of the JSON string from that conversion
keel-core/src/main/kotlin/com/netflix/spinnaker/keel/serialization/ObjectMappers.kt
Outdated
Show resolved
Hide resolved
keel-core/src/main/java/com/netflix/spinnaker/keel/serialization/PrecisionSqlSerializer.java
Show resolved
Hide resolved
...-core-test/src/main/kotlin/com/netflix/spinnaker/keel/persistence/ArtifactRepositoryTests.kt
Outdated
Show resolved
Hide resolved
| @@ -1 +1 @@ | |||
| ryuk.container.image = public.ecr.aws/s4w6t4b6/testcontainers/ryuk:0.3.4 | |||
| ryuk.container.image = testcontainers/ryuk:0.11.0 | |||
There was a problem hiding this comment.
FYI the ECR image wasn't working in local testing - thus the need to switch. PROBABLY should use docker.io/testcontainers/ryuk:0.11.0 but this works
| apply { | ||
| fun <T : ObjectMapper> T.configureForKeel(): T { | ||
| val javaTimeModule = JavaTimeModule() | ||
| javaTimeModule.addSerializer(Instant::class.java,PrecisionSqlSerializer()) |
There was a problem hiding this comment.
Can we add a round trip test that uses the serializer and then deserializes to ensure precision is in fact kept? Other than that, this PR looks good
There was a problem hiding this comment.
It's actually tested indirectly via the ArtifactRepositoryTests file but let me see about a direct test. It'll only keep as much precision as it writes in the JSON fields. So this WILL reduce precision on these columns from what the JVM could track - but it's never had that until java 17 it looks like so we're not losing anything - though I may try to do a "6" instead of "3" precision as docs say MySQL CAN handle that level.
There was a problem hiding this comment.
Added a test see what you think :)
|
Looks good! One thing Im a little un sure on is the change from 3 to 6. I get it is for mysql, but does this cover everything? Im guessing yes but with sqlite, oracle, microsoft, my hope is this will cover all of those unless we explicitly say that we dont guarantee for those DBs. |
|
SHOULD cover most of them if I recall. TECHNICALLY Spinnaker supports MySQL & Postgresql :) I wouldn't mind oracle but definitely would be syntax changes. AND this is really mostly impactful because it's auto generating a column off of a JSON Instant string. IF You're persisting DIRECT to a datetime field, I THOUGHT the database drivers kick in on reducing the precision with warnings about it - which can have interesting impacts if you're NOT cognizant of the reduction. A quick search says postgresql has the same precision of 6. And... as I recalled oracle LOOKS like 9 aka much higher. I'd BET SQLLite has a higher precision because of how it operates/stores things, but ... not dug as much there and probably very platform specific. |
|
to note, the problem really is java.time.Instant usage - which... is NOT all that common. Particularly the toString on it - if we were using say OffSet or one of the others... it'd help. OR we could have this as a standard in the kork serialization stuff. |
| @@ -35,7 +35,7 @@ public PrecisionSqlSerializer() { | |||
| Instant::toEpochMilli, | |||
| Instant::getEpochSecond, | |||
| Instant::getNano, | |||
| new DateTimeFormatterBuilder().appendInstant(3).toFormatter()); | |||
| new DateTimeFormatterBuilder().appendInstant(6).toFormatter()); | |||
There was a problem hiding this comment.
The comment above about using 3 digits could use a tweak.
There was a problem hiding this comment.
Was waiting for tests to pass ;) LOOKS Like they're happy with the 6 precision, though datetime(3) MAY truncate it more. The question there to my mind is... do we want this to go to 3 or 6?
There was a problem hiding this comment.
What did we have with java 11?
There was a problem hiding this comment.
Was the point for this? To just allow for more precision? If that's the case, we may want to just leave it at 3. Like I said that was the only thing I was unsure of, but more precision also does not hurt, but Spinnaker also doesn't need ot be the most precise service either
There was a problem hiding this comment.
Java 11 looks like only supported 6 digits of precision. It wasn't until 17 and it seems VERY tied to the OS on what level it supports. In this particular case what's MORE important is that databases don't support more than 6 (that we support)
There was a problem hiding this comment.
Maybe I'm getting tripped up in the wording, but isn't there a difference between what java 11 supports, and what keel actually used? I'd prefer to keep it the same as what we had if possible.
There was a problem hiding this comment.
SO not quite. Java 11 supported and delivered 6 digits of precision at MOST. Java 17 ALLOWED a higher level of precision if the system clock supported it. Instant.toString was never consistent on the output - it would just output the MOST available. This led to situations where when doing serialization to JSON, you'd get inconsistent results. And on an OS with HIGHER precision, you'd go over the bounds that the database supported. SO the primary impact and root of the problem is when Keel does auto generated fields OFF of the JSON string in date format, causing a failure. Java was always able to handle it, but databases didn't handle the higher precision UNLESS they were storing things as a string (which most are). Timestamp fields however would NOT work.
SO the key on this is to serialize at MAX precision for the storage layer. NOTE: There are POTENTIAL headaches on tests in other places if we do comparisons of what's written & read on unit tests in a real database. SQLLite being Java MAY support a higher preceision - but I'd bet it depends on compatibility mode. SO if we have a test that writes the timestamps using a mysql test container, then tries to do an equals on a read of that timestamp it will NOT work as mysql wouldn't support the full precision that the JVM supports.
There was a problem hiding this comment.
To note... Orca uses LONG's for persistence of timestamps - so it worked without issue. It's JUST keel that stores times as Instants and in string format. Least so far that I found. That was the original headache with a simple replacement serialization implementation - I had to switch to the time base serializer which is smarter on it's handling.
There was a problem hiding this comment.
OK, sounds like we're going with 6. I guess we don't include keel in our release notes, so we're off the hook there :)
There was a problem hiding this comment.
I should correct H2 was what was thinking on memory. SQLlite looks like it supports 6 - but there are extensions to add more precision (again just a quick search on this one)
...-core-test/src/main/kotlin/com/netflix/spinnaker/keel/persistence/ArtifactRepositoryTests.kt
Outdated
Show resolved
Hide resolved
No description provided.