gstackoverflow's questions

Li a documentação do Spring Boot sobre observabilidade e vi a seção sobreBaggage

Você pode criar bagagem com a API Tracer:

@Component
class CreatingBaggage {

  private final Tracer tracer;

  CreatingBaggage(Tracer tracer) {
      this.tracer = tracer;
  }

  void doSomething() {
      try (BaggageInScope scope = this.tracer.createBaggageInScope("baggage1", "value1")) {
          // Business logic
      }
  }

}

Este exemplo cria uma bagagem chamada baggage1 com o valor value1. A bagagem é propagada automaticamente pela rede se você estiver usando a propagação W3C. Se você estiver usando a propagação B3, a bagagem não é propagada automaticamente. Para propagar manualmente a bagagem pela rede, use a propriedade de configuração management.tracing.baggage.remote-fields (isso também funciona para W3C). Para o exemplo acima, definir essa propriedade como baggage1 resulta em um cabeçalho HTTP baggage1: value1.

Se você quiser propagar a bagagem para o MDC, use a propriedade de configuração management.tracing.baggage.correlation.fields. Para o exemplo acima, definir essa propriedade como baggage1 resulta em uma entrada MDC chamada baggage1.

Não me deparei com bagagem no contexto de rastreamento e não consigo encontrar nenhuma definição clara.

Você poderia explicar o que é bagagem e como ela se relaciona com o rastreamento?

Agora tenho o seguinte código para criar uma nova conexão:

        return LDAPConnection(opts, host, port).apply {
            connectionName = "foo-$userDn-$host-$port"
            processExtendedOperation(StartTLSExtendedRequest(SSLUtil(TrustAllTrustManager()).createSSLContext()))
            bind(userDn, password)
        }      

Agora quero mudar para usar LDAPConnectionPool.

Eu tentei fazer isso:

        val simpleBindRequest = SimpleBindRequest(userDn, password)
        val exampleConnection = LDAPConnection(opts, host, port).apply {
            connectionName = "foo-$userDn-$host-$port"
            processExtendedOperation(StartTLSExtendedRequest(SSLUtil(TrustAllTrustManager()).createSSLContext()))
            bind(simpleBindRequest )
        }      
        val ldapConnectionPool = LDAPConnectionPool(exampleConnection , 1, 10)
        ldapConnectionPool.setBindRequest(simpleBindRequest)           

mais tarde em algum pedaço de código eu faço a chamada pela primeira vez

connectionPool.getConnection()

e funciona porque retorna a conexão passada inicialmente ( exampleConnection)

mas quando eu faço uma ligação

connectionPool.getConnection()

pela segunda vez recebo LDAPException:

LDAPException(resultCode=8 (autenticação forte necessária), diagnosticMessage='BindSimple: Criptografia de transporte necessária. ', ldapSDKVersion=6.0.11, revisão=8b21d0a4c6eb8b5c3e60a96fc3e9e13b9c2f650f) em com.unboundid.ldap.sdk.LDAPConnectionPool.createConnection(LDAPConnectionPool.java:1388) em com.unboundid.ldap.sdk.LDAPConnectionPool.createConnection(LDAPConnectionPool.java:1269) em com.unboundid.ldap.sdk.LDAPConnectionPool.getConnection(LDAPConnectionPool.java:1866)

Suponho que seja por causa de

 processExtendedOperation(StartTLSExtendedRequest(SSLUtil(TrustAllTrustManager()).createSSLContext()))

não é chamado

Existe uma maneira de consertar isso?

Em Java Streams é recomendado evitar usar estado compartilhado em foreach.
Prova: java streams doc

Efeitos colaterais Efeitos colaterais em parâmetros comportamentais para operações de fluxo são, em geral, desencorajados, pois podem frequentemente levar a violações involuntárias do requisito de ausência de estado, bem como outros riscos de segurança de thread. Se os parâmetros comportamentais tiverem efeitos colaterais, a menos que explicitamente declarado, não há garantias quanto à visibilidade desses efeitos colaterais para outros threads, nem há garantias de que operações diferentes no "mesmo" elemento dentro do mesmo pipeline de fluxo sejam executadas no mesmo thread. Além disso, a ordenação desses efeitos pode ser surpreendente. Mesmo quando um pipeline é restrito a produzir um resultado que seja consistente com a ordem de encontro da fonte de fluxo (por exemplo, IntStream.range(0,5).parallel().map(x -> x*2).toArray() deve produzir [0, 2, 4, 6, 8]), nenhuma garantia é feita quanto à ordem em que a função mapeadora é aplicada a elementos individuais, ou em qual thread qualquer parâmetro comportamental é executado para um dado elemento.

Muitas computações onde alguém pode ser tentado a usar efeitos colaterais podem ser expressas de forma mais segura e eficiente sem efeitos colaterais, como usar redução em vez de acumuladores mutáveis. No entanto, efeitos colaterais como usar println() para propósitos de depuração são geralmente inofensivos. Um pequeno número de operações de fluxo, como forEach() e peek(), podem operar somente por meio de efeitos colaterais; estes devem ser usados ​​com cuidado.

Como exemplo de como transformar um pipeline de fluxo que usa efeitos colaterais de forma inadequada em um que não o faz, o código a seguir pesquisa um fluxo de strings em busca daquelas que correspondem a uma determinada expressão regular e coloca as correspondências em uma lista.

 ArrayList<String> results = new ArrayList<>();
 stream.filter(s -> pattern.matcher(s).matches())
       .forEach(s -> results.add(s));  // Unnecessary use of side-effects!

Este código usa efeitos colaterais desnecessariamente. Se executado em paralelo, a não segurança de thread de ArrayList causaria resultados incorretos, e adicionar a sincronização necessária causaria contenção, minando o benefício do paralelismo. Além disso, usar efeitos colaterais aqui é completamente desnecessário; o forEach() pode ser simplesmente substituído por uma operação de redução que é mais segura, mais eficiente e mais passível de paralelismo:

 List<String>results =
     stream.filter(s -> pattern.matcher(s).matches())
           .collect(Collectors.toList());  // No side-effects!

Não consigo encontrar as mesmas recomendações para Kotlin.

Devo evitar esse código em Kotlin?

var bar = foo(myPath)
myPath.forEach { e ->
    ...         
    bar = foo(bar,....)
}

Eu tenho uma aula de DTO

class MyDto {
   private String f1;
   private String f2; 
   private String f3;
   // constructor
   // get set equals/hashCode
}

Ele tem equal/ hascodepar que leva em conta todos os 3 campos.

Por favor, dê uma olhada no teste

...
var actualList = service.getActualList(...)
assertThat(actualList, containsInAnyOrder(new MyDto("a1","","c1"), new MyDto("a2","","c2")) )
...

Ele falha porque f2é gerado no lado do banco de dados (então não consigo prever o valor desse campo).

Quero passar um comparador personalizado para fazer uma comparação específica de teste. É possível fazer isso no Hamcrest?

PS: Não quero reescrever equals/hashcode porque não estará correto do meu ponto de vista de lógica de negócios

Eu tenho uma função

fun foo(
    id: String,
    vararg values: Int,
){
  ...    
}

e há chamadas como essas

fun bar1(){
    foo("id_1")
    foo("id_2", 1)
    foo("id_3", 1, 2, 3)
}

Agora entendi que preciso adicionar mais um argumento para foo. mas não quero interromper chamadas existentes, então tentei adicioná-lo com valores padrão:

fun foo(
    id: String,
    attributes: Array<String> = arrayOf("a", "b"),
    vararg values: Int,
){
  ...
}

Mas

foo("id_2", 1)
foo("id_3", 1, 2, 3)

ficou quebrado.

Existe uma maneira de adicionar mais um argumento com valor padrão sem interromper as chamadas existentes?

Li o tópico Gerar apenas um endpoint específico da API

Mas eu tenho uma tarefa um pouco diferente, quero excluir alguns endpoints específicos da geração. Por que preciso disso? Temos um experimento em que o analytics escreve um esquema de API aberto e, se eles adicionam um novo endpoint ao controlador existente, isso leva a um erro de compilação (requer a implementação de um novo método na interface). Queremos evitar esse erro sem implementar o stub.

Existe uma maneira de conseguir isso?

Eu apreciaria um exemplo de gradle (build.gradle.kts)

Eu tenho uma função:

fun foo(arg1: Int, arg2: String, lambda: (String, Int) -> Int): Int {
    return arg1 + arg2.length + lambda("123", 1)
}

Agora quero ligar e fazer o seguinte:

fun bar() {
    foo(1, "2") { (a, b) -> 42 }
}

Mas tende a compilar erros:

Expected 2 parameters of types String, Int
Destructuring declarations initializer of type String must have a 'component1()' function

Eu também tentei usar tipos explicitamente

fun bar() {
    foo(1, "2") { (a:String, b:Int) -> 42 }
}

mas ainda erro de compilação:

required (String,Int) -> Int
but found: (String) -> Int

Eu preciso de uma função que será lançada MapparaMap<String, List<Int>>

Atualmente uso "as" inseguro, mas recebo um aviso justo sobre isso. Eu quero consertar isso.

Para a parte da lista consegui implementar a função

inline fun <reified T : Any> List<*>.checkItemsAre(): List<T> {
    return this.filterIsInstance<T>().takeIf { it.size == this.size }
        ?: throw IllegalArgumentException("Can't convert raw List to type safe List")
}

Mas não posso financiar analógico para mapa.

Como posso consertar isso?